@thigasdevelopment/luam 0.19.6 → 0.19.10

package/luam.mjs

@@ -431,7 +431,7 @@ var require_help = __commonJS({
         if (option.argChoices) {
           extraInfo.push(
             // use stringify to match the display of the default value
-            `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`
+            `choices: ${option.argChoices.map((choice2) => JSON.stringify(choice2)).join(", ")}`
           );
         }
         if (option.defaultValue !== void 0) {
@@ -464,7 +464,7 @@ var require_help = __commonJS({
         if (argument.argChoices) {
           extraInfo.push(
             // use stringify to match the display of the default value
-            `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`
+            `choices: ${argument.argChoices.map((choice2) => JSON.stringify(choice2)).join(", ")}`
           );
         }
         if (argument.defaultValue !== void 0) {
@@ -3121,13 +3121,24 @@ function reportAssignedConflict(assigned, fromDirective, mapped, diagnostics) {
   const message = `${origin} "${assigned}" environment but the directive declares "${fromDirective}". The directive wins.`;
   diagnostics.push(createDiagnostic("checker", "env-path-directive-conflict", message, FILE_START, "warning"));
 }
-function resolveEnvironment(filePath, directives, fromMapping = null) {
+function reportLockedConflict(assigned, fromDirective, diagnostics) {
+  const subject = `A library declares this file as "${assigned}" but the directive declares "${fromDirective}"`;
+  const message = `${subject}. A library declares its layout once, in the "luam" field of its "package.json". Remove the directive.`;
+  diagnostics.push(createDiagnostic("checker", "env-library-directive", message, FILE_START));
+}
+function resolveEnvironment(filePath, directives, fromMapping = null, locked = false) {
   const diagnostics = [];
   const fromPath = filePath === null ? null : environmentFromPath(filePath);
   const found = collectDirectiveEnvironments(directives);
   const fromDirective = found[0] ?? null;
   const assigned = fromMapping ?? fromPath;
   reportConflictingDirectives(found, diagnostics);
+  if (locked && assigned !== null) {
+    if (fromDirective !== null && fromDirective !== assigned) {
+      reportLockedConflict(assigned, fromDirective, diagnostics);
+    }
+    return { environment: assigned, fromPath, fromMapping, fromDirective, diagnostics };
+  }
   if (assigned !== null && fromDirective !== null) {
     reportAssignedConflict(assigned, fromDirective, fromMapping !== null, diagnostics);
   }
@@ -4449,8 +4460,8 @@ function parseSuffixed(stream) {
 }
 function parseUnary(stream) {
   const token = stream.current();
-  const isUnary = (token.kind === "operator" || token.kind === "keyword") && UNARY_OPERATORS.has(token.value);
-  if (!isUnary) {
+  const isUnary2 = (token.kind === "operator" || token.kind === "keyword") && UNARY_OPERATORS.has(token.value);
+  if (!isUnary2) {
     return parseSuffixed(stream);
   }
   stream.next();
@@ -5175,6 +5186,8 @@ var ESCAPING_PATH = "config-escaping-path";
 var UNKNOWN_HELPER = "config-unknown-helper";
 var INVALID_PATTERN = "config-invalid-pattern";
 var INVALID_DEPENDENCY = "config-invalid-dependency";
+var INVALID_LIBRARY = "config-library-invalid";
+var DUPLICATE_LIBRARY = "config-library-duplicate";
 var INVALID_ENGINE_VERSION = "config-invalid-engine-version";
 var REMOVED_FIELD = "config-removed-field";
 var ALLOWED_STATEMENTS = 'A manifest holds only "local" declarations and assignments to configuration fields.';
@@ -5802,6 +5815,12 @@ var MANIFEST_FIELDS = [
     owner: "dependencies",
     allowEmpty: true
   }),
+  field("libraries", STRING_LIST, "Luam library packages compiled into the resource, in the order they are emitted.", {
+    defaultValue: [],
+    rule: "package-name",
+    owner: "libraries",
+    allowEmpty: true
+  }),
   field("contracts", STRING_TYPE, "Directory the export contract is written to and dependency contracts are read from.", {
     defaultValue: DEFAULT_CONTRACTS_DIR,
     rule: "contained-path",
@@ -5966,8 +5985,8 @@ function isNumber(type) {
 function isText(type) {
   return type.kind === "string" || type.kind === "string-literal" || type.kind === "any";
 }
-function fail(operator, expected, left, right, describe2) {
-  const culprit = describe2(isNumber(left) || isText(left) ? right : left);
+function fail(operator, expected, left, right, describe3) {
+  const culprit = describe3(isNumber(left) || isText(left) ? right : left);
   return { evaluated: null, error: `"${operator}" expects ${expected} on both sides but received ${culprit}.` };
 }
 function arithmetic(operator, left, right) {
@@ -6006,22 +6025,22 @@ function applyOr(left, right) {
   const value = isTruthy(left.value) ? left.value : right.value;
   return { value, type: unionOf([left.truthy, right.type]), truthy: unionOf([left.truthy, right.truthy]), falsy: right.falsy };
 }
-function applyOrdering(operator, left, right, describe2) {
+function applyOrdering(operator, left, right, describe3) {
   const numeric = isNumber(left.type) && isNumber(right.type);
   const textual = isText(left.type) && isText(right.type);
   if (!numeric && !textual) {
-    return fail(operator, "two numbers or two strings", left.type, right.type, describe2);
+    return fail(operator, "two numbers or two strings", left.type, right.type, describe3);
   }
   return { evaluated: booleanValue(compare(operator, left.value, right.value)), error: null };
 }
-function applyConcat(left, right, describe2) {
+function applyConcat(left, right, describe3) {
   const usable = (type) => isText(type) || isNumber(type);
   if (!usable(left.type) || !usable(right.type)) {
-    return fail("..", "a string or a number", left.type, right.type, describe2);
+    return fail("..", "a string or a number", left.type, right.type, describe3);
   }
   return { evaluated: stringValue(`${left.value}${right.value}`), error: null };
 }
-function applyBinary(operator, left, right, describe2) {
+function applyBinary(operator, left, right, describe3) {
   if (operator === "and") {
     return { evaluated: applyAnd(left, right), error: null };
   }
@@ -6033,23 +6052,23 @@ function applyBinary(operator, left, right, describe2) {
     return { evaluated: booleanValue(operator === "==" ? same : !same), error: null };
   }
   if (ORDERING.includes(operator)) {
-    return applyOrdering(operator, left, right, describe2);
+    return applyOrdering(operator, left, right, describe3);
   }
   if (operator === "..") {
-    return applyConcat(left, right, describe2);
+    return applyConcat(left, right, describe3);
   }
   if (!isNumber(left.type) || !isNumber(right.type)) {
-    return fail(operator, "a number", left.type, right.type, describe2);
+    return fail(operator, "a number", left.type, right.type, describe3);
   }
   return { evaluated: numberValue(arithmetic(operator, left.value, right.value)), error: null };
 }
-function applyUnary(operator, operand, describe2) {
+function applyUnary(operator, operand, describe3) {
   if (operator === "not") {
     return { evaluated: booleanValue(!isTruthy(operand.value)), error: null };
   }
   if (operator === "-") {
     if (!isNumber(operand.type)) {
-      return { evaluated: null, error: `"-" expects a number but received ${describe2(operand.type)}.` };
+      return { evaluated: null, error: `"-" expects a number but received ${describe3(operand.type)}.` };
     }
     return { evaluated: numberValue(-operand.value), error: null };
   }
@@ -6385,6 +6404,130 @@ function watchRoots(patterns) {
   return roots.filter((root) => !roots.some((other) => other.length < root.length && root.startsWith(`${other}/`)));
 }
 
+// ../compiler/src/project/library.ts
+function compareLibraryOrigins(left, right) {
+  return left.packageIndex - right.packageIndex || left.index - right.index;
+}
+var LIBRARIES_DIRECTORY = "libs";
+var LIBRARY_FIELD = "luam";
+var MISSING_LIBRARY = "config-library-missing";
+var INVALID_LIBRARY2 = "config-library-invalid";
+var ESCAPING_LIBRARY = "config-library-escape";
+var MISSING_REQUIREMENT = "config-library-requirement-missing";
+var PACKAGE_NAME = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+var SHAPE = `"${LIBRARY_FIELD}" must be a table with "sources" naming patterns per side and an optional "requires" list.`;
+function isPackageName(value) {
+  return PACKAGE_NAME.test(value);
+}
+function libraryDirectory(name) {
+  return name.replace(/^@/, "").replace(/\//g, "-");
+}
+function libraryFilePath(name, relativePath2) {
+  return `${name}/${normalizePattern(relativePath2)}`;
+}
+function libraryOutputPath(name, environment, relativePath2) {
+  const file = normalizePattern(relativePath2).replace(/\.luam$/, ".lua");
+  return `${LIBRARIES_DIRECTORY}/${libraryDirectory(name)}/${environment}/${file}`;
+}
+function installCommand(name) {
+  return `npm install ${name}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringList(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  return value.every((entry) => typeof entry === "string") ? [...value] : null;
+}
+function patternProblems(name, environment, patterns, problems) {
+  for (const pattern of patterns) {
+    const problem = patternProblem(pattern);
+    if (problem === null) {
+      continue;
+    }
+    const code = problem === "absolute" || problem === "traversal" ? ESCAPING_LIBRARY : INVALID_LIBRARY2;
+    const subject = `"${name}" declares the "${environment}" pattern "${pattern}", which ${patternProblemText(problem)}`;
+    problems.push({ code, message: `${subject}. Every pattern stays inside the package directory.` });
+  }
+}
+function readSources(name, value, problems) {
+  if (!isRecord(value)) {
+    problems.push({ code: INVALID_LIBRARY2, message: `"${name}" declares no "sources" table in its "${LIBRARY_FIELD}" field. ${SHAPE}` });
+    return null;
+  }
+  const mapping = emptySourceMapping();
+  for (const environment of SOURCE_SIDES) {
+    const declared = value[environment];
+    if (declared === void 0) {
+      continue;
+    }
+    const patterns = stringList(declared);
+    if (patterns === null) {
+      problems.push({ code: INVALID_LIBRARY2, message: `"${name}" declares "sources.${environment}" as something other than a list of patterns. ${SHAPE}` });
+      continue;
+    }
+    patternProblems(name, environment, patterns, problems);
+    mapping[environment] = patterns.map(normalizePattern);
+  }
+  if (SOURCE_SIDES.every((environment) => mapping[environment].length === 0)) {
+    problems.push({ code: INVALID_LIBRARY2, message: `"${name}" declares no source patterns for any side. ${SHAPE}` });
+    return null;
+  }
+  return mapping;
+}
+function readRequires(name, value, problems) {
+  if (value === void 0) {
+    return [];
+  }
+  const requires = stringList(value);
+  if (requires === null) {
+    problems.push({ code: INVALID_LIBRARY2, message: `"${name}" declares "requires" as something other than a list of package names. ${SHAPE}` });
+    return [];
+  }
+  for (const entry of requires) {
+    if (!isPackageName(entry)) {
+      problems.push({ code: INVALID_LIBRARY2, message: `"${name}" requires "${entry}", which is not a package name.` });
+    }
+  }
+  return requires.filter(isPackageName);
+}
+function readLibraryDeclaration(name, manifest) {
+  const problems = [];
+  if (!isRecord(manifest)) {
+    return { declaration: null, problems: [{ code: INVALID_LIBRARY2, message: `"${name}" has an unreadable "package.json". ${SHAPE}` }] };
+  }
+  const field2 = manifest[LIBRARY_FIELD];
+  if (field2 === void 0) {
+    const message = `"${name}" is listed in "libraries" but its "package.json" declares no "${LIBRARY_FIELD}" field, so it is not a Luam library.`;
+    return { declaration: null, problems: [{ code: INVALID_LIBRARY2, message }] };
+  }
+  if (!isRecord(field2)) {
+    return { declaration: null, problems: [{ code: INVALID_LIBRARY2, message: `"${name}" declares a "${LIBRARY_FIELD}" field that is not a table. ${SHAPE}` }] };
+  }
+  const sources = readSources(name, field2.sources, problems);
+  const requires = readRequires(name, field2.requires, problems);
+  if (sources === null) {
+    return { declaration: null, problems };
+  }
+  return { declaration: { name, sources, requires }, problems };
+}
+function missingRequirements(declarations) {
+  const listed = new Set(declarations.map((declaration) => declaration.name));
+  const problems = [];
+  for (const declaration of declarations) {
+    for (const required of declaration.requires) {
+      if (listed.has(required)) {
+        continue;
+      }
+      const subject = `"${declaration.name}" requires "${required}", which "libraries" does not list`;
+      problems.push({ code: MISSING_REQUIREMENT, message: `${subject}. Add it to "libraries" and install it with "${installCommand(required)}".` });
+    }
+  }
+  return problems;
+}
+
 // ../compiler/src/manifest/manifest-rules.ts
 var START = createPosition(1, 1, 0);
 var RESOURCE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
@@ -6477,6 +6620,9 @@ var RuleWalk = class {
     if (entry.rule === "dependency-name" && !isValidResourceName(value)) {
       this.report(INVALID_DEPENDENCY, `"${path}" must be a valid MTA resource name but received "${value}".`, key);
     }
+    if (entry.rule === "package-name" && !isPackageName(value)) {
+      this.report(INVALID_LIBRARY, `"${path}" must be the name of an installed npm package but received "${value}".`, key);
+    }
   }
   version(entry, value, path, key) {
     if (entry.rule !== "engine-version" || value === LATEST_ENGINE_VERSION || ENGINE_VERSION.test(value)) {
@@ -6513,6 +6659,7 @@ function normalizeManifest(value, positions) {
 }
 
 // ../compiler/src/manifest/manifest-analysis.ts
+var MANIFEST_SCHEMA = { fields: MANIFEST_FIELDS, removed: REMOVED_FIELDS, normalize: normalizeManifest };
 var START2 = createPosition(1, 1, 0);
 function statementError(kind) {
   return `A manifest cannot contain ${kind}. ${ALLOWED_STATEMENTS}`;
@@ -6542,7 +6689,7 @@ function readLocal(pass, statement) {
     pass.declareLocal(declaration.name, value === void 0 ? nilValue() : pass.evaluate(value, null), declaration.position);
   }
 }
-function readAssignment(pass, statement, assignments, value) {
+function readAssignment(pass, statement, assignments, value, schema) {
   const [target] = statement.targets;
   const [expression] = statement.values;
   if (statement.operator !== "=" || statement.targets.length !== 1 || statement.values.length !== 1 || target === void 0 || expression === void 0) {
@@ -6553,11 +6700,11 @@ function readAssignment(pass, statement, assignments, value) {
     pass.report(INVALID_STATEMENT, statementError("an assignment to anything but a configuration field"), target.position);
     return;
   }
-  const field2 = findField(MANIFEST_FIELDS, target.name);
+  const field2 = findField(schema.fields, target.name);
   if (field2 === null) {
-    const replacement = REMOVED_FIELDS[target.name];
+    const replacement = schema.removed[target.name];
     if (replacement === void 0) {
-      pass.report(UNKNOWN_FIELD, unknownNameMessage(target.name), target.position);
+      pass.report(UNKNOWN_FIELD, (schema.unknownName ?? unknownNameMessage)(target.name), target.position);
     } else {
       pass.report(REMOVED_FIELD, `"${target.name}" is no longer a manifest field. ${replacement}`, target.position);
     }
@@ -6566,25 +6713,25 @@ function readAssignment(pass, statement, assignments, value) {
   assignments.push({ name: target.name, position: target.position, value: expression });
   value[target.name] = pass.expression(expression, { field: field2, path: target.name, key: target.name }).value;
 }
-function readStatement(pass, statement, assignments, value) {
+function readStatement(pass, statement, assignments, value, schema) {
   if (statement.kind === "local-statement") {
     readLocal(pass, statement);
     return;
   }
   if (statement.kind === "assignment-statement") {
-    readAssignment(pass, statement, assignments, value);
+    readAssignment(pass, statement, assignments, value, schema);
     return;
   }
   pass.report(INVALID_STATEMENT, statementError(STATEMENT_NAMES[statement.kind] ?? "this statement"), statement.position);
 }
-function reportMissing(diagnostics, value) {
-  for (const field2 of requiredFields(MANIFEST_FIELDS)) {
+function reportMissing(diagnostics, value, schema) {
+  for (const field2 of requiredFields(schema.fields)) {
     if (value[field2.name] === void 0) {
       diagnostics.push(manifestError(MISSING_FIELD, `The manifest requires a "${field2.name}" field. ${field2.summary}`, START2));
     }
   }
 }
-function analyzeManifest(source, context) {
+function analyzeManifest(source, context, schema = MANIFEST_SCHEMA) {
   const parsed = parse(source);
   const pass = new ManifestPass(context);
   const assignments = [];
@@ -6593,15 +6740,15 @@ function analyzeManifest(source, context) {
     pass.report(INVALID_STATEMENT, statementError(`the "#!${directive}" directive`), START2);
   }
   for (const statement of parsed.program.body) {
-    readStatement(pass, statement, assignments, raw);
+    readStatement(pass, statement, assignments, raw, schema);
   }
-  reportMissing(pass.diagnostics, raw);
+  reportMissing(pass.diagnostics, raw, schema);
   pass.diagnostics.push(...pass.locals.unused());
-  const normalized = normalizeManifest(raw, pass.positions);
+  const normalized = schema.normalize(raw, pass.positions);
   return {
     program: parsed.program,
     tokens: parsed.tokens,
-    diagnostics: sortDiagnostics([...parsed.diagnostics, ...pass.diagnostics, ...normalized.diagnostics]),
+    diagnostics: sortDiagnostics([...parsed.diagnostics, ...pass.diagnostics, ...normalized.diagnostics]).map(schema.retag ?? ((entry) => entry)),
     value: normalized.value,
     raw,
     positions: pass.positions,
@@ -6673,6 +6820,9 @@ function readAssetMappings(value) {
 function readDependencies(value) {
   return [...new Set(readStrings(value, "dependencies"))].sort();
 }
+function readLibraries(value) {
+  return readStrings(value, "libraries");
+}
 function readEngine(value) {
   const source = readTable(value, "engine") ?? EMPTY;
   return { minVersion: readString(source, "minVersion") ?? DEFAULT_ENGINE.minVersion };
@@ -6732,10 +6882,20 @@ function checkDependencies(name, dependencies, context) {
     }
   }
 }
+function checkLibraries(libraries, context) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, library] of libraries.entries()) {
+    if (seen.has(library)) {
+      context.error(DUPLICATE_LIBRARY, `"libraries" lists "${library}" more than once. Keep one entry.`, `libraries.${index}`);
+    }
+    seen.add(library);
+  }
+}
 function validateConfig(value, positions) {
   const context = new ValidationContext(positions);
   const name = readString(value, "name") ?? "";
   const dependencies = readDependencies(value);
+  const libraries = readLibraries(value);
   const config = {
     name,
     author: readString(value, "author"),
@@ -6745,6 +6905,7 @@ function validateConfig(value, positions) {
     sources: readSourceMapping(value),
     assets: readAssetMappings(value),
     dependencies,
+    libraries,
     contracts: readString(value, "contracts") ?? "",
     engine: readEngine(value),
     environment: readEnvironmentFiles(value),
@@ -6757,6 +6918,7 @@ function validateConfig(value, positions) {
     development: readDevelopment(readTable(value, "development"))
   };
   checkDependencies(name, dependencies, context);
+  checkLibraries(libraries, context);
   return { config, diagnostics: context.diagnostics };
 }
 
@@ -6810,7 +6972,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.19.6" : "0.0.0-dev";
+var VERSION = true ? "0.19.10" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -7344,6 +7506,9 @@ function manifestOption() {
 function colorOption() {
   return new Option("--no-color", "Print plain output with no colour and no emoji.");
 }
+function jsonOption() {
+  return new Option("--json", "Write one machine-readable document to stdout instead of the human report.");
+}
 function offlineOption() {
   return new Option("--offline", "Skip the MTA release lookup and use the cached version, if there is one.");
 }
@@ -7459,15 +7624,15 @@ function knowsResource(contracts, resource) {
 }
 function buildResourceAbi(resource, contributions) {
   const exports = contributions.map((contribution) => {
-    const signature = contribution.signature;
+    const signature2 = contribution.signature;
     return {
       name: contribution.name,
       side: contribution.side,
       http: contribution.http,
-      parameters: signature?.parameters ?? [],
-      minimumArguments: signature?.minimumArguments ?? 0,
-      variadic: signature?.variadic ?? true,
-      returns: signature?.returns ?? "any"
+      parameters: signature2?.parameters ?? [],
+      minimumArguments: signature2?.minimumArguments ?? 0,
+      variadic: signature2?.variadic ?? true,
+      returns: signature2?.returns ?? "any"
     };
   });
   return { abi: ABI_VERSION, resource, exports };
@@ -7524,6 +7689,175 @@ function readHelperSource(helper, file) {
   return readFileSync4(resolveHelperPath(helper, file), "utf8");
 }
 
+// src/build/library-resolution.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
+
+// src/build/project-files.ts
+import { readdirSync, statSync as statSync2 } from "node:fs";
+import { join as join3, relative, resolve as resolve5 } from "node:path";
+function isDirectory(path) {
+  try {
+    return statSync2(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function relativePath(root, absolute) {
+  return normalizePattern(relative(root, absolute));
+}
+function walk(root, directory, excluded, tree) {
+  let entries3;
+  try {
+    entries3 = readdirSync(directory, { withFileTypes: true });
+  } catch (error) {
+    tree.errors.push(`"${relativePath(root, directory)}" could not be read: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  for (const entry of entries3) {
+    const absolute = join3(directory, entry.name);
+    const path = relativePath(root, absolute);
+    if (path.length === 0 || isExcludedPath(path, excluded)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      walk(root, absolute, excluded, tree);
+    } else if (entry.isFile()) {
+      tree.files.push(path);
+    }
+  }
+}
+function listProjectFiles(root, roots, excluded = []) {
+  const tree = { files: [], errors: [] };
+  const seen = /* @__PURE__ */ new Set();
+  for (const start of [...new Set(roots)].sort()) {
+    const absolute = resolve5(root, start);
+    if (!isDirectory(absolute) || seen.has(absolute)) {
+      continue;
+    }
+    seen.add(absolute);
+    walk(root, absolute, excluded, tree);
+  }
+  return { files: [...new Set(tree.files)].sort(), errors: tree.errors };
+}
+
+// ../compiler/src/project/source-kind.ts
+var SOURCE_EXTENSION = ".luam";
+var DECLARATION_EXTENSION = ".d.luam";
+var TEST_EXTENSION = ".test.luam";
+function isDeclarationPath(path) {
+  return normalizePath(path).endsWith(DECLARATION_EXTENSION);
+}
+function isSourcePath(path) {
+  return normalizePath(path).endsWith(SOURCE_EXTENSION);
+}
+function isTestPath(path) {
+  return normalizePath(path).endsWith(TEST_EXTENSION);
+}
+
+// src/build/library-resolution.ts
+var LUA_EXTENSION = ".lua";
+var PACKAGE_MANIFEST = "package.json";
+var MODULES_DIRECTORY = "node_modules";
+function packageRoot(root, name) {
+  return resolve6(root, MODULES_DIRECTORY, ...name.split("/"));
+}
+function readPackageManifest(path) {
+  try {
+    return JSON.parse(readFileSync5(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var SIDE_ORDER = ["shared", "server", "client"];
+function orderedPatterns(declaration) {
+  return SIDE_ORDER.flatMap((environment) => declaration.sources[environment].map((pattern) => ({ environment, pattern })));
+}
+function matchFile(path, patterns) {
+  const order = patterns.findIndex((entry) => matchesPattern(entry.pattern, path));
+  const matched = patterns[order];
+  if (matched === void 0) {
+    return null;
+  }
+  return { relativePath: path, environment: matched.environment, order };
+}
+function matchedFiles(root, declaration, diagnostics) {
+  const patterns = orderedPatterns(declaration);
+  const roots = [...new Set(patterns.map((entry) => entry.pattern))];
+  const tree = listProjectFiles(root, watchRoots(roots));
+  const matched = [];
+  for (const path of tree.files) {
+    if (isTestPath(path) || !path.endsWith(SOURCE_EXTENSION) && !path.endsWith(LUA_EXTENSION)) {
+      continue;
+    }
+    const found = matchFile(path, patterns);
+    if (found !== null) {
+      matched.push(found);
+    }
+  }
+  for (const message of tree.errors) {
+    diagnostics.push(cliError(INVALID_LIBRARY2, `"${declaration.name}" could not be read: ${message}`));
+  }
+  return matched.sort((left, right) => left.order - right.order || left.relativePath.localeCompare(right.relativePath));
+}
+function readLibraryFile(root, relativePath2, name, diagnostics) {
+  try {
+    return readFileSync5(resolve6(root, relativePath2), "utf8");
+  } catch (error) {
+    const reason2 = error instanceof Error ? error.message : String(error);
+    diagnostics.push(cliError(INVALID_LIBRARY2, `"${libraryFilePath(name, relativePath2)}" could not be read: ${reason2}`));
+    return null;
+  }
+}
+function collectFiles(root, declaration, packageIndex, resolved2) {
+  const matched = matchedFiles(root, declaration, resolved2.diagnostics);
+  for (const [index, entry] of matched.entries()) {
+    const content = readLibraryFile(root, entry.relativePath, declaration.name, resolved2.diagnostics);
+    if (content === null) {
+      continue;
+    }
+    const origin = { package: declaration.name, root, relativePath: entry.relativePath, packageIndex, index };
+    if (entry.relativePath.endsWith(LUA_EXTENSION)) {
+      resolved2.verbatim.push({ origin, environment: entry.environment, content });
+      continue;
+    }
+    resolved2.files.push({ path: libraryFilePath(declaration.name, entry.relativePath), source: content, environment: entry.environment, origin });
+  }
+}
+function resolveLibrary(root, name, packageIndex, resolved2) {
+  const directory = packageRoot(root, name);
+  const manifestPath = resolve6(directory, PACKAGE_MANIFEST);
+  if (!existsSync4(manifestPath)) {
+    const subject = `"${name}" is listed in "libraries" but is not installed`;
+    resolved2.diagnostics.push(cliError(MISSING_LIBRARY, `${subject}. Install it with "${installCommand(name)}" and build again.`));
+    return;
+  }
+  const declaration = readLibraryDeclaration(name, readPackageManifest(manifestPath));
+  for (const problem of declaration.problems) {
+    resolved2.diagnostics.push(cliError(problem.code, problem.message));
+  }
+  if (declaration.declaration === null) {
+    return;
+  }
+  resolved2.libraries.push({ declaration: declaration.declaration, root: directory });
+  collectFiles(directory, declaration.declaration, packageIndex, resolved2);
+}
+function resolveLibraries(root, names) {
+  const resolved2 = { libraries: [], files: [], verbatim: [], diagnostics: [] };
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (seen.has(name)) {
+      continue;
+    }
+    seen.add(name);
+    resolveLibrary(root, name, seen.size - 1, resolved2);
+  }
+  for (const problem of missingRequirements(resolved2.libraries.map((library) => library.declaration))) {
+    resolved2.diagnostics.push(cliError(problem.code, problem.message));
+  }
+  return resolved2;
+}
+
 // src/build/build-phase.ts
 var COUNTED_PHASES = /* @__PURE__ */ new Set(["compile", "write"]);
 var PHASE_LABELS = {
@@ -7590,60 +7924,12 @@ function createPhaseTracker(listener = null) {
 }
 
 // src/build/project-inputs.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "node:fs";
+import { resolve as resolve8 } from "node:path";
 
 // src/build/asset-resolution.ts
 import { statSync as statSync3 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
-
-// src/build/project-files.ts
-import { readdirSync, statSync as statSync2 } from "node:fs";
-import { join as join3, relative, resolve as resolve5 } from "node:path";
-function isDirectory(path) {
-  try {
-    return statSync2(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function relativePath(root, absolute) {
-  return normalizePattern(relative(root, absolute));
-}
-function walk(root, directory, excluded, tree) {
-  let entries3;
-  try {
-    entries3 = readdirSync(directory, { withFileTypes: true });
-  } catch (error) {
-    tree.errors.push(`"${relativePath(root, directory)}" could not be read: ${error instanceof Error ? error.message : String(error)}`);
-    return;
-  }
-  for (const entry of entries3) {
-    const absolute = join3(directory, entry.name);
-    const path = relativePath(root, absolute);
-    if (path.length === 0 || isExcludedPath(path, excluded)) {
-      continue;
-    }
-    if (entry.isDirectory()) {
-      walk(root, absolute, excluded, tree);
-    } else if (entry.isFile()) {
-      tree.files.push(path);
-    }
-  }
-}
-function listProjectFiles(root, roots, excluded = []) {
-  const tree = { files: [], errors: [] };
-  const seen = /* @__PURE__ */ new Set();
-  for (const start of [...new Set(roots)].sort()) {
-    const absolute = resolve5(root, start);
-    if (!isDirectory(absolute) || seen.has(absolute)) {
-      continue;
-    }
-    seen.add(absolute);
-    walk(root, absolute, excluded, tree);
-  }
-  return { files: [...new Set(tree.files)].sort(), errors: tree.errors };
-}
+import { resolve as resolve7 } from "node:path";
 
 // ../compiler/src/project/resource-map.ts
 var RESOURCE_MAP_VERSION = 1;
@@ -7717,11 +8003,12 @@ var ENVIRONMENTS2 = ["shared", "server", "client"];
 function bundlePath(environment) {
   return `${BUNDLE_DIRECTORY}/${environment}.lua`;
 }
-function collectBundles(helpers, scripts, pinned) {
+function collectBundles(helpers, scripts, pinned, libraries = []) {
   const pinnedPaths = new Set(pinned.map((script) => script.path));
   return ENVIRONMENTS2.flatMap((environment) => {
     const environmentHelpers = helpers.filter((helper) => helper.environment === environment).map((helper) => ({ kind: "helper", helper }));
     const orderedModules = [
+      ...libraries.filter((script) => script.environment === environment),
       ...pinned.filter((script) => script.environment === environment),
       ...scripts.filter((script) => script.environment === environment && !pinnedPaths.has(script.path))
     ].map((module) => ({ kind: "module", module }));
@@ -7779,6 +8066,9 @@ var OCCUPIED_SIDES = {
 function occupiedSides(contribution) {
   return OCCUPIED_SIDES[contribution.side];
 }
+function sidesOf(environment) {
+  return OCCUPIED_SIDES[environment];
+}
 function exportSignature(type) {
   if (type === void 0 || type.kind !== "function") {
     return null;
@@ -7801,10 +8091,11 @@ function toContributions(directives, environment, globals) {
 var INDENT = "    ";
 var RESOURCE_TYPE = "script";
 var DEFAULT_SIDE = "server";
-var SIDE_ORDER = { shared: 0, server: 1, client: 2 };
-var SCRIPT_GROUPS = ["library", "configuration", "source"];
+var SIDE_ORDER2 = { shared: 0, server: 1, client: 2 };
+var SCRIPT_GROUPS = ["library", "libraries", "configuration", "source"];
 var GROUP_COMMENTS = {
   library: "Runtime library",
+  libraries: "Libraries",
   configuration: "Configuration",
   source: "Source scripts"
 };
@@ -7867,7 +8158,7 @@ function versionElement(version) {
   return `${INDENT}<min_mta_version ${attribute("server", version)} ${attribute("client", version)} />`;
 }
 function exportElements(contributions) {
-  return [...contributions].sort((left, right) => SIDE_ORDER[left.side] - SIDE_ORDER[right.side] || left.name.localeCompare(right.name)).map(exportElement);
+  return [...contributions].sort((left, right) => SIDE_ORDER2[left.side] - SIDE_ORDER2[right.side] || left.name.localeCompare(right.name)).map(exportElement);
 }
 function scriptSections(scripts) {
   return SCRIPT_GROUPS.flatMap((group) => section(GROUP_COMMENTS[group], scripts.filter((script) => script.group === group).map(scriptElement)));
@@ -7951,16 +8242,39 @@ function collectDevelopmentLogHelpers(options) {
     replacements
   }));
 }
+function emitted(modules) {
+  return modules.filter((module) => module.code !== null);
+}
 function collectScripts(modules) {
-  return modules.filter((module) => module.code !== null).map((module) => ({ path: outputPath(module.path), source: module.path, environment: module.environment, content: module.code, lines: module.lines })).sort((left, right) => ENVIRONMENT_ORDER[left.environment] - ENVIRONMENT_ORDER[right.environment] || left.path.localeCompare(right.path));
+  return emitted(modules).filter((module) => module.origin === null).map((module) => ({ path: outputPath(module.path), source: module.path, environment: module.environment, content: module.code, lines: module.lines })).sort((left, right) => ENVIRONMENT_ORDER[left.environment] - ENVIRONMENT_ORDER[right.environment] || left.path.localeCompare(right.path));
+}
+function libraryScript(origin, environment, content, lines) {
+  const script = {
+    path: libraryOutputPath(origin.package, environment, origin.relativePath),
+    source: libraryFilePath(origin.package, origin.relativePath),
+    environment,
+    content,
+    lines
+  };
+  return { origin, script };
+}
+function collectLibraryScripts(modules, files = []) {
+  const compiled = emitted(modules).filter((module) => module.origin !== null).map((module) => libraryScript(module.origin, module.environment, module.code, module.lines));
+  const verbatim = files.map((file) => libraryScript(file.origin, file.environment, file.content, []));
+  return [...compiled, ...verbatim].sort((left, right) => compareLibraryOrigins(left.origin, right.origin)).map((entry) => entry.script);
 }
 var MISSING_LOAD_ORDER = 'is listed in "loadOrder" but no source file or asset matches it. Remove the entry or correct the path.';
+var LIBRARY_LOAD_ORDER = 'is listed in "loadOrder" but belongs to a library. Library scripts load in the order "libraries" declares. Remove the entry.';
 function missingEntry(entry) {
   return { path: entry, diagnostic: createDiagnostic("project", "project-load-order-missing", `"${entry}" ${MISSING_LOAD_ORDER}`, FILE_START) };
 }
-function resolveLoadOrder(entries3, scripts, assets) {
+function libraryEntry(entry) {
+  return { path: entry, diagnostic: createDiagnostic("project", "project-load-order-library", `"${entry}" ${LIBRARY_LOAD_ORDER}`, FILE_START) };
+}
+function resolveLoadOrder(entries3, scripts, assets, libraries = []) {
   const byScript = new Map(scripts.map((script) => [normalizePath(script.source), script]));
   const byAsset = new Map(assets.map((asset) => [normalizePath(asset.source), asset]));
+  const byLibrary = new Set(libraries.map((script) => normalizePath(script.source)));
   const resolved2 = { scripts: [], assets: [], diagnostics: [] };
   const seen = /* @__PURE__ */ new Set();
   for (const entry of entries3) {
@@ -7972,7 +8286,7 @@ function resolveLoadOrder(entries3, scripts, assets) {
     }
     seen.add(path);
     if (script === void 0 && asset === void 0) {
-      resolved2.diagnostics.push(missingEntry(entry));
+      resolved2.diagnostics.push(byLibrary.has(path) ? libraryEntry(entry) : missingEntry(entry));
       continue;
     }
     if (script !== void 0) {
@@ -8133,9 +8447,9 @@ function withEnvironmentFile(helpers, file) {
 function helperEntry(helper) {
   return { src: helper.path, environment: helper.environment, group: "library" };
 }
-function manifestScripts(helpers, configuration, sources) {
+function manifestScripts(helpers, libraries, configuration, sources) {
   const settings = configuration === null ? [] : [{ src: configuration.path, environment: "shared", group: "configuration" }];
-  return [...helpers.map(helperEntry), ...settings, ...sources];
+  return [...helpers.map(helperEntry), ...libraries, ...settings, ...sources];
 }
 function collectContributions(project) {
   return project.modules.flatMap((module) => module.contributions);
@@ -8208,32 +8522,35 @@ function assembleResource(project, options, onStep) {
   const collected = [...collectHelpers(project.modules, options.helpers ?? []), ...collectDevelopmentLogHelpers(options.developmentLogs)];
   const helpers = withEnvironmentFile(collected, options.environmentFile);
   const scripts = collectScripts(project.modules);
+  const libraries = collectLibraryScripts(project.modules, options.libraryFiles ?? []);
   const configuration = configurationScript(options.configuration);
   const deployment = configuration === null ? [] : [configuration];
-  const sorted = [...options.assets ?? []].sort((left, right) => left.path.localeCompare(right.path));
-  const order = resolveLoadOrder(options.loadOrder ?? [], scripts, sorted);
+  const sorted2 = [...options.assets ?? []].sort((left, right) => left.path.localeCompare(right.path));
+  const order = resolveLoadOrder(options.loadOrder ?? [], scripts, sorted2, libraries);
   const layout = options.layout ?? "tree";
-  const bundles = layout === "bundle" ? collectBundles(helpers, scripts, order.scripts) : [];
-  const duplicates = layout === "tree" ? findDuplicateOutputs([...scripts, ...deployment], sorted) : [...findDuplicateOutputs(scripts, []), ...findDuplicateOutputs(deployment, sorted)];
-  const collisions = layout === "bundle" ? bundleDiagnostics(project, bundles, scripts, sorted) : [];
+  const bundles = layout === "bundle" ? collectBundles(helpers, scripts, order.scripts, libraries) : [];
+  const duplicates = layout === "tree" ? findDuplicateOutputs([...libraries, ...scripts, ...deployment], sorted2) : [...findDuplicateOutputs([...libraries, ...scripts], []), ...findDuplicateOutputs(deployment, sorted2)];
+  const collisions = layout === "bundle" ? bundleDiagnostics(project, bundles, scripts, sorted2) : [];
   const diagnostics = sortFileDiagnostics([...project.diagnostics, ...duplicates, ...collisions, ...order.diagnostics]);
   if (duplicates.length > 0 || collisions.length > 0 || order.diagnostics.length > 0) {
     return { build: null, diagnostics };
   }
   onStep?.("assembly");
-  const assets = orderAssets(sorted, order.assets);
+  const assets = orderAssets(sorted2, order.assets);
   const sources = layout === "tree" ? sourceEntries(scripts, order.scripts).map((entry) => ({ ...entry, group: "source" })) : bundles.map((bundle) => ({ src: bundle.path, environment: bundle.environment, group: "source" }));
   const manifestHelpers = layout === "tree" ? helpers : [];
+  const vendored = layout === "tree" ? libraries.map((script) => ({ src: script.path, environment: script.environment, group: "libraries" })) : [];
   const manifest = generateManifest(
     manifestInfo(options),
-    manifestScripts(manifestHelpers, configuration, sources),
+    manifestScripts(manifestHelpers, vendored, configuration, sources),
     manifestFiles(assets),
     collectContributions(project),
     { oop: options.oop === true, minMtaVersion: options.minMtaVersion ?? null, dependencies: options.dependencies ?? [] }
   );
   onStep?.("manifest");
-  const map = layout === "tree" ? treeResourceMap(options.resourceName ?? "", scripts) : null;
-  return { build: { manifest, scripts: layout === "tree" ? scripts : [], helpers, configuration, assets, bundles, layout, map }, diagnostics };
+  const written = [...libraries, ...scripts];
+  const map = layout === "tree" ? treeResourceMap(options.resourceName ?? "", written) : null;
+  return { build: { manifest, scripts: layout === "tree" ? written : [], helpers, configuration, assets, bundles, layout, map }, diagnostics };
 }
 
 // src/build/asset-resolution.ts
@@ -8243,14 +8560,14 @@ var MANIFEST_OUTPUT = "meta.xml";
 var HERE = ".";
 function isDirectory2(root, path) {
   try {
-    return statSync3(resolve6(root, path)).isDirectory();
+    return statSync3(resolve7(root, path)).isDirectory();
   } catch {
     return false;
   }
 }
 function exists(root, path) {
   try {
-    statSync3(resolve6(root, path));
+    statSync3(resolve7(root, path));
     return true;
   } catch {
     return false;
@@ -8318,10 +8635,10 @@ var CONFIGURATION_FILE = "config.lua";
 var MALFORMED_ENV = "build-env-malformed";
 var MISSING_ENV = "config-missing-env-file";
 function readTextFile(path) {
-  return existsSync4(path) ? readFileSync5(path, "utf8") : null;
+  return existsSync5(path) ? readFileSync6(path, "utf8") : null;
 }
 function readEnvironment(root, file, required, diagnostics) {
-  const source = readTextFile(resolve7(root, file));
+  const source = readTextFile(resolve8(root, file));
   if (source === null) {
     if (required) {
       diagnostics.push(cliError(MISSING_ENV, `"${file}" is configured under "environment" but does not exist. Create it or remove the setting.`));
@@ -8335,7 +8652,7 @@ function readEnvironment(root, file, required, diagnostics) {
   return parsed;
 }
 function readConfiguration(root, diagnostics) {
-  const content = readTextFile(resolve7(root, CONFIGURATION_FILE));
+  const content = readTextFile(resolve8(root, CONFIGURATION_FILE));
   if (content === null) {
     return null;
   }
@@ -8354,14 +8671,14 @@ function readProjectInputs(root, options) {
 }
 
 // src/build/source-discovery.ts
-import { readFileSync as readFileSync6 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { resolve as resolve9 } from "node:path";
 
 // ../compiler/src/project/source-mapping.ts
 function createSourceResolver(mapping) {
   const matchers = new Map(SOURCE_SIDES.map((environment) => [environment, createPatternMatcher(mapping[environment])]));
   const patterns = SOURCE_SIDES.flatMap((environment) => [...matchers.get(environment)?.patterns ?? []]);
-  function resolve21(path) {
+  function resolve24(path) {
     const normalized = normalizePattern(path);
     const matches = [];
     for (const environment of SOURCE_SIDES) {
@@ -8375,25 +8692,14 @@ function createSourceResolver(mapping) {
   return {
     patterns,
     roots: watchRoots(patterns),
-    resolve: resolve21,
-    side: (path) => resolve21(path).environment
+    resolve: resolve24,
+    side: (path) => resolve24(path).environment
   };
 }
 function describeMatches(matches) {
   return matches.map((match) => `"${match.environment}" through "${match.pattern}"`).join(" and ");
 }
 
-// ../compiler/src/project/source-kind.ts
-var SOURCE_EXTENSION = ".luam";
-var DECLARATION_EXTENSION = ".d.luam";
-var TEST_EXTENSION = ".test.luam";
-function isDeclarationPath(path) {
-  return normalizePath(path).endsWith(DECLARATION_EXTENSION);
-}
-function isTestPath(path) {
-  return normalizePath(path).endsWith(TEST_EXTENSION);
-}
-
 // src/build/source-discovery.ts
 var MISSING_SOURCE = "config-missing-source";
 var NO_SOURCES = "config-no-sources";
@@ -8419,7 +8725,7 @@ function checkLiterals(root, resolver, found, diagnostics) {
 }
 function readSource(root, path, diagnostics) {
   try {
-    return readFileSync6(resolve8(root, path), "utf8");
+    return readFileSync7(resolve9(root, path), "utf8");
   } catch (error) {
     diagnostics.push(cliError(UNREADABLE_SOURCE, `The source file "${path}" could not be read: ${error instanceof Error ? error.message : String(error)}`));
     return null;
@@ -14990,12 +15296,12 @@ function failed(type) {
 function entries2(parts) {
   return `{ ${parts.join(", ")} }`;
 }
-function combine(parts, render2) {
+function combine(parts, render3) {
   const broken = parts.find((part) => part.lua === null);
   if (broken !== void 0) {
     return broken;
   }
-  return { lua: render2(parts.map((part) => part.lua)), unreifiable: null };
+  return { lua: render3(parts.map((part) => part.lua)), unreifiable: null };
 }
 function namedDescriptor(context, type, name, seen) {
   if (context.declarations.lookupClass(name) !== null) {
@@ -18610,60 +18916,60 @@ function selectCandidate(context, expression, forms) {
   });
   return found[0] ?? null;
 }
-function specialize(signature, candidate) {
+function specialize(signature2, candidate) {
   const callback = candidate.form.callbackArgument;
   if (callback !== void 0) {
-    const parameters = [...signature.parameters];
+    const parameters = [...signature2.parameters];
     parameters[callback] = candidate.handler;
-    return { ...signature, parameters };
+    return { ...signature2, parameters };
   }
   const payload = candidate.form.payloadArgument;
   if (payload === void 0) {
     return null;
   }
   return createFunction(
-    [...signature.parameters.slice(0, payload), ...candidate.handler.parameters],
-    signature.returnType,
+    [...signature2.parameters.slice(0, payload), ...candidate.handler.parameters],
+    signature2.returnType,
     payload + candidate.handler.minimumArguments,
     candidate.handler.isVariadic,
     void 0,
     candidate.handler.variadicType
   );
 }
-function specializeEventCall(context, expression, signature) {
-  if (signature.kind !== "function" || expression.method !== null || expression.callee.kind !== "identifier") {
+function specializeEventCall(context, expression, signature2) {
+  if (signature2.kind !== "function" || expression.method !== null || expression.callee.kind !== "identifier") {
     return null;
   }
   const forms = eventCallForms(expression.callee.name);
   const candidate = selectCandidate(context, expression, forms);
-  return candidate === null ? null : specialize(signature, candidate);
+  return candidate === null ? null : specialize(signature2, candidate);
 }
 
 // ../compiler/src/checker/generic-call.ts
 function countArguments(total) {
   return total === 1 ? "1 type argument" : `${total} type arguments`;
 }
-function substituteSignature(signature, substitutions) {
-  const parameters = signature.parameters.map((parameter) => substituteType(parameter, substitutions));
-  const returnType = substituteType(signature.returnType, substitutions);
-  const variadicType = signature.variadicType === void 0 ? void 0 : substituteType(signature.variadicType, substitutions);
-  return createFunction(parameters, returnType, signature.minimumArguments, signature.isVariadic, signature.parameterNames, variadicType);
+function substituteSignature(signature2, substitutions) {
+  const parameters = signature2.parameters.map((parameter) => substituteType(parameter, substitutions));
+  const returnType = substituteType(signature2.returnType, substitutions);
+  const variadicType = signature2.variadicType === void 0 ? void 0 : substituteType(signature2.variadicType, substitutions);
+  return createFunction(parameters, returnType, signature2.minimumArguments, signature2.isVariadic, signature2.parameterNames, variadicType);
 }
-function specializeCall(context, owner, signature, argumentTypes, typeArguments, position2) {
-  const names = signature.typeParameters ?? [];
+function specializeCall(context, owner, signature2, argumentTypes, typeArguments, position2) {
+  const names = signature2.typeParameters ?? [];
   if (names.length === 0) {
     if (typeArguments.length > 0) {
       context.report("check-generic-arity", `${owner} does not accept type arguments.`, position2);
     }
-    return signature;
+    return signature2;
   }
   const explicit = typeArguments.map((argument) => context.resolveAnnotation(argument));
   if (typeArguments.length > 0 && explicit.length !== names.length) {
     context.report("check-generic-arity", `${owner} expects ${countArguments(names.length)} but received ${explicit.length}.`, position2);
   }
-  const resolved2 = typeArguments.length > 0 ? names.map((unused, index) => explicit[index] ?? ANY_TYPE) : inferTypeArguments(names, signature.parameters, argumentTypes);
-  reportConstraintViolations(context, owner, names, signature.typeConstraints ?? [], resolved2, position2);
-  return substituteSignature(signature, new Map(names.map((name, index) => [name, resolved2[index] ?? ANY_TYPE])));
+  const resolved2 = typeArguments.length > 0 ? names.map((unused, index) => explicit[index] ?? ANY_TYPE) : inferTypeArguments(names, signature2.parameters, argumentTypes);
+  reportConstraintViolations(context, owner, names, signature2.typeConstraints ?? [], resolved2, position2);
+  return substituteSignature(signature2, new Map(names.map((name, index) => [name, resolved2[index] ?? ANY_TYPE])));
 }
 
 // ../compiler/src/checker/method-receiver.ts
@@ -18675,13 +18981,13 @@ function resolveNonNominalMethod(receiver, method) {
   const member = receiver.members.get(method);
   return member !== void 0 && member.kind === "function" ? member : null;
 }
-function withoutSelfParameter(signature) {
-  const names = signature.parameterNames;
+function withoutSelfParameter(signature2) {
+  const names = signature2.parameterNames;
   if (names === void 0 || names[0] !== SELF_PARAMETER) {
-    return signature;
+    return signature2;
   }
-  const minimum = Math.max(0, signature.minimumArguments - 1);
-  return createFunction(signature.parameters.slice(1), signature.returnType, minimum, signature.isVariadic, names.slice(1), signature.variadicType);
+  const minimum = Math.max(0, signature2.minimumArguments - 1);
+  return createFunction(signature2.parameters.slice(1), signature2.returnType, minimum, signature2.isVariadic, names.slice(1), signature2.variadicType);
 }
 
 // ../compiler/src/checker/resource-exports.ts
@@ -18979,6 +19285,7 @@ function resolveMtaMember(context, className, name, position2) {
 }
 
 // ../compiler/src/checker/members.ts
+var SELF_RECEIVER = "self";
 function checkEnumMember(context, name, members, expression) {
   if (members.includes(expression.property)) {
     return NUMBER_TYPE;
@@ -19039,6 +19346,35 @@ function resolveStaticMember(context, className, expression) {
   context.report("check-unknown-member", `Class "${className}" has no static member "${expression.property}".${hint}`, expression.position);
   return ANY_TYPE;
 }
+function isFullyDeclared(context, className) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = context.declarations.lookupClass(className);
+  while (current !== null && !visited.has(current.name)) {
+    visited.add(current.name);
+    if (current.hasUnresolvedParent === true || current.interfaces.some((name) => context.declarations.lookupInterface(name) === null)) {
+      return false;
+    }
+    if (current.superClass === null) {
+      return true;
+    }
+    current = context.declarations.lookupClass(current.superClass);
+  }
+  return current !== null;
+}
+function isSelfReceiver(receiver) {
+  return receiver.kind === "identifier" && receiver.name === SELF_RECEIVER;
+}
+function reportUnknownClassMember(context, className, property, position2) {
+  const names = context.declarations.collectMembers(className).map((member) => `"${member.name}"`);
+  const known = names.length === 0 ? "It declares no members." : `Declared members: ${names.join(", ")}.`;
+  context.report("check-unknown-member", `Class "${className}" has no member "${property}". ${known}`, position2);
+}
+function checkClassMember(context, className, expression) {
+  if (!isSelfReceiver(expression.object)) {
+    reportUnknownClassMember(context, className, expression.property, expression.position);
+  }
+  return ANY_TYPE;
+}
 function resolveNamedMember(context, receiver, expression) {
   const name = receiver.name;
   const enumeration = context.declarations.lookupEnum(name);
@@ -19064,13 +19400,39 @@ function resolveNamedMember(context, receiver, expression) {
   if (context.awaitsDeclaration(name)) {
     return ANY_TYPE;
   }
-  const contract = context.declarations.lookupClass(name) === null ? context.declarations.lookupInterface(name) : null;
+  if (context.declarations.lookupClass(name) !== null) {
+    return isFullyDeclared(context, name) ? checkClassMember(context, name, expression) : null;
+  }
+  const contract = context.declarations.lookupInterface(name);
   if (contract === null) {
     return null;
   }
   const members = new Map(context.declarations.collectMembers(name).map((member2) => [member2.name, member2]));
   return checkInterfaceMember(context, name, members, expression);
 }
+function reportUnknownMethod(context, receiver, callee, method, position2) {
+  const name = receiver.name;
+  if (context.declarations.lookupEnum(name) !== null || context.awaitsDeclaration(name) || isSelfReceiver(callee)) {
+    return;
+  }
+  const staticMember = context.declarations.lookupStaticMember(name, method);
+  if (staticMember !== null) {
+    const message = `"${method}" is a static member of class "${name}". Call it as "${name}.${method}(...)".`;
+    context.report("check-static-receiver", message, position2);
+    return;
+  }
+  if (context.declarations.lookupClass(name) !== null) {
+    if (isFullyDeclared(context, name)) {
+      reportUnknownClassMember(context, name, method, position2);
+    }
+    return;
+  }
+  if (context.declarations.lookupInterface(name) === null) {
+    return;
+  }
+  const keys = context.declarations.collectMembers(name).map((member) => `"${member.name}"`).join(", ");
+  context.report("check-unknown-member", `Interface "${name}" has no member "${method}". Declared members: ${keys}.`, position2);
+}
 var NATIVE_CONSTRUCTOR = "new";
 function nativeConstructor(context, name) {
   const symbol = context.binder.lookup(name);
@@ -19127,9 +19489,9 @@ function checkNewExpression(context, expression) {
   const constructor = context.declarations.lookupMember(expression.className, "constructor");
   if (constructor !== null && constructor.type.kind === "function") {
     const substitutions = info === null ? /* @__PURE__ */ new Map() : classSubstitutions(info, typeArguments);
-    const signature = substituteType(constructor.type, substitutions);
-    if (signature.kind === "function") {
-      checkSignature(context, expression.args, signature, expression.position);
+    const signature2 = substituteType(constructor.type, substitutions);
+    if (signature2.kind === "function") {
+      checkSignature(context, expression.args, signature2, expression.position);
     }
   } else {
     expression.args.forEach((argument) => checkExpression(context, argument));
@@ -19658,7 +20020,7 @@ function reportMissingReturn(context, declared, position2) {
   const repair = declared.kind === "tuple" ? "Add a return on every path." : `Add a return on every path, or declare "${name}?".`;
   context.report("check-missing-return", `This function declares "${name}" but can end without returning a value. ${repair}`, position2);
 }
-function checkFunctionBody(context, parameters, returnAnnotation, body, signature, selfType2, position2 = ORIGIN) {
+function checkFunctionBody(context, parameters, returnAnnotation, body, signature2, selfType2, position2 = ORIGIN) {
   forgetAssignedPaths(context, body);
   const entry = context.flowState;
   context.setFlow(cloneFlow(entry));
@@ -19669,7 +20031,7 @@ function checkFunctionBody(context, parameters, returnAnnotation, body, signatur
   }
   let parameterIndex = 0;
   for (const parameter of parameters) {
-    const type = parameter.isVararg ? ANY_TYPE : signature.parameters[parameterIndex] ?? ANY_TYPE;
+    const type = parameter.isVararg ? ANY_TYPE : signature2.parameters[parameterIndex] ?? ANY_TYPE;
     context.binder.declare({ name: parameter.name, type, isLocal: true, position: parameter.position, origin: "parameter" });
     if (!parameter.isVararg) {
       parameterIndex += 1;
@@ -19682,7 +20044,7 @@ function checkFunctionBody(context, parameters, returnAnnotation, body, signatur
   }
   const inferred = context.popReturnType();
   if (returnAnnotation === null) {
-    signature.returnType = inferred;
+    signature2.returnType = inferred;
   }
   context.binder.popScope();
   context.setFlow(entry);
@@ -19982,32 +20344,32 @@ function countArguments2(total) {
 }
 function checkSignature(context, args, declared, position2, owner = "This call", typeArguments = []) {
   const argumentTypes = checkValueList(context, args, declared.parameters);
-  const signature = specializeCall(context, owner, declared, argumentTypes, typeArguments, position2);
-  if (argumentTypes.length < signature.minimumArguments) {
-    const message = `This call expects at least ${countArguments2(signature.minimumArguments)} but received ${argumentTypes.length}.`;
+  const signature2 = specializeCall(context, owner, declared, argumentTypes, typeArguments, position2);
+  if (argumentTypes.length < signature2.minimumArguments) {
+    const message = `This call expects at least ${countArguments2(signature2.minimumArguments)} but received ${argumentTypes.length}.`;
     context.report("check-argument-count", message, position2);
   }
-  if (!signature.isVariadic && argumentTypes.length > signature.parameters.length) {
-    const message = `This call expects at most ${countArguments2(signature.parameters.length)} but received ${argumentTypes.length}.`;
+  if (!signature2.isVariadic && argumentTypes.length > signature2.parameters.length) {
+    const message = `This call expects at most ${countArguments2(signature2.parameters.length)} but received ${argumentTypes.length}.`;
     context.report("check-argument-count", message, position2);
   }
-  signature.parameters.forEach((parameter, index) => {
+  signature2.parameters.forEach((parameter, index) => {
     const argumentType = argumentTypes[index];
     const argument = args[index];
     if (argumentType !== void 0 && argument !== void 0) {
       context.expectAssignable(argumentType, parameter, argument.position, `Argument ${index + 1}`);
     }
   });
-  if (signature.isVariadic && signature.variadicType !== void 0) {
-    for (let index = signature.parameters.length; index < argumentTypes.length; index += 1) {
+  if (signature2.isVariadic && signature2.variadicType !== void 0) {
+    for (let index = signature2.parameters.length; index < argumentTypes.length; index += 1) {
       const argumentType = argumentTypes[index];
       const argument = args[Math.min(index, args.length - 1)];
       if (argumentType !== void 0 && argument !== void 0) {
-        context.expectAssignable(argumentType, signature.variadicType, argument.position, `Argument ${index + 1}`);
+        context.expectAssignable(argumentType, signature2.variadicType, argument.position, `Argument ${index + 1}`);
       }
     }
   }
-  return signature.returnType;
+  return signature2.returnType;
 }
 function callOwner(expression) {
   const name = expression.method ?? (expression.callee.kind === "identifier" ? expression.callee.name : null);
@@ -20029,12 +20391,12 @@ function isLegacySuperCall(expression) {
 }
 function checkMethodCall(context, expression, method, receiver) {
   if (receiver.kind !== "named") {
-    const signature = resolveNonNominalMethod(receiver, method);
-    if (signature === null) {
+    const signature2 = resolveNonNominalMethod(receiver, method);
+    if (signature2 === null) {
       checkValueList(context, expression.args);
       return ANY_TYPE;
     }
-    return checkSignature(context, expression.args, withoutSelfParameter(signature), expression.position, callOwner(expression), expression.typeArguments);
+    return checkSignature(context, expression.args, withoutSelfParameter(signature2), expression.position, callOwner(expression), expression.typeArguments);
   }
   const declared = memberOf(context, receiver, method);
   if (declared?.type.kind === "function") {
@@ -20044,6 +20406,9 @@ function checkMethodCall(context, expression, method, receiver) {
     return checkSignature(context, expression.args, declared.type, expression.position, callOwner(expression), expression.typeArguments);
   }
   if (!isMtaElement(context, receiver.name)) {
+    if (declared === null) {
+      reportUnknownMethod(context, receiver, expression.callee, method, expression.position);
+    }
     checkValueList(context, expression.args);
     return ANY_TYPE;
   }
@@ -20104,8 +20469,8 @@ function checkTable(context, expression) {
     }
     return checkExpression(context, field2.value);
   });
-  const isRecord = expression.fields.every((field2) => field2.name !== null);
-  if (isRecord) {
+  const isRecord2 = expression.fields.every((field2) => field2.name !== null);
+  if (isRecord2) {
     const members = /* @__PURE__ */ new Map();
     expression.fields.forEach((field2, index) => {
       if (field2.name !== null) {
@@ -20328,18 +20693,22 @@ function checkMethodBody(context, info, member) {
   if (explicitSelf !== void 0) {
     context.report("check-explicit-self-parameter", 'Class methods receive "self" automatically; remove it from the parameter list.', explicitSelf.position);
   }
-  const signature = (member.isStatic ? info.statics : info.members).get(member.name)?.type;
-  if (signature?.kind !== "function") {
+  const signature2 = (member.isStatic ? info.statics : info.members).get(member.name)?.type;
+  if (signature2?.kind !== "function") {
     return;
   }
   if (member.isStatic) {
-    checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, null, member.position);
+    checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature2, null, member.position);
     return;
   }
   context.pushClassMethod({ className: info.name, methodName: member.name });
-  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, selfType(info), member.position);
+  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature2, selfType(info), member.position);
   context.popClassMethod();
 }
+function assignSuperClass(context, info, statement) {
+  info.superClass = resolveSuperClass(context, statement);
+  info.hasUnresolvedParent = statement.superClass !== null && info.superClass === null;
+}
 function resolveSuperClass(context, statement) {
   if (statement.superClass === null) {
     return null;
@@ -20394,7 +20763,7 @@ function declareLocalClass(context, statement) {
   if (info === null) {
     return null;
   }
-  info.superClass = resolveSuperClass(context, statement);
+  assignSuperClass(context, info, statement);
   resolveClassHeader(context, info, statement);
   return info;
 }
@@ -20508,7 +20877,7 @@ function breakCycle(context, info) {
 function predeclareModule(context, body) {
   const declared = declareHeaders(context, body);
   for (const entry of declared) {
-    entry.info.superClass = resolveSuperClass(context, entry.statement);
+    assignSuperClass(context, entry.info, entry.statement);
     resolveClassHeader(context, entry.info, entry.statement);
   }
   for (const entry of declared) {
@@ -20685,9 +21054,9 @@ function finalizeEmission(code, markers, sourceLineOffset = 0) {
       continue;
     }
     const marker = markers[Number(match[1])];
-    const emitted = line2.replace(pattern, "");
+    const emitted2 = line2.replace(pattern, "");
     if (marker === void 0) {
-      output.push(emitted);
+      output.push(emitted2);
       continue;
     }
     while (output.length + 1 < marker.sourceLine - sourceLineOffset) {
@@ -20697,7 +21066,7 @@ function finalizeEmission(code, markers, sourceLineOffset = 0) {
     if (marker.symbol !== void 0) {
       mapping.symbol = marker.symbol;
     }
-    output.push(emitted);
+    output.push(emitted2);
     const sameSegment = previous !== null && previous.symbol === mapping.symbol && previous.sourceLine - previous.generatedLine === mapping.sourceLine - mapping.generatedLine;
     if (!sameSegment) {
       mappings.push(mapping);
@@ -20838,10 +21207,10 @@ function emitFunctionBody(state, parameters, body, header) {
   const lines = emitBlock(state, body);
   state.loopWrap = previous;
   state.indent -= 1;
-  const signature = `${header}(${emitParameters(parameters)})`;
+  const signature2 = `${header}(${emitParameters(parameters)})`;
   const closing = indentLine(state, "end");
-  return lines.length === 0 ? `${signature}
-${closing}` : `${signature}
+  return lines.length === 0 ? `${signature2}
+${closing}` : `${signature2}
 ${lines.join("\n")}
 ${closing}`;
 }
@@ -21535,8 +21904,8 @@ function erasedEdit(source, span) {
 }
 function canonicalEdit(input, statement, span) {
   const { source } = input;
-  const emitted = emit2({ ...input.program, body: [statement] }, input.types, input.references, input.generatedMembers, statement.position.line - 1, input.staticAccess);
-  const trimmed = span.end < source.length && emitted.code.endsWith("\n") ? emitted.code.slice(0, -1) : emitted.code;
+  const emitted2 = emit2({ ...input.program, body: [statement] }, input.types, input.references, input.generatedMembers, statement.position.line - 1, input.staticAccess);
+  const trimmed = span.end < source.length && emitted2.code.endsWith("\n") ? emitted2.code.slice(0, -1) : emitted2.code;
   if (trimmed.length === 0) {
     return erasedEdit(source, span);
   }
@@ -21547,7 +21916,7 @@ function canonicalEdit(input, statement, span) {
     return null;
   }
   const padded = missing2 > 0 && source.slice(span.end).trim().length > 0 ? `${replacement}${"\n".repeat(missing2)}` : replacement;
-  return { start: span.start, end: span.end, replacement: padded, lines: emitted.lines };
+  return { start: span.start, end: span.end, replacement: padded, lines: emitted2.lines };
 }
 
 // ../compiler/src/emitter/preserve-decorators.ts
@@ -22020,7 +22389,7 @@ function compile(source, options = {}) {
   const settings = options.compilerOptions ?? DEFAULT_COMPILER_OPTIONS;
   const parsed = parse(source);
   const mode = resolveStrictMode(parsed.directives, settings.strict);
-  const resolved2 = resolveEnvironment(options.filePath ?? null, parsed.directives, options.environment ?? null);
+  const resolved2 = resolveEnvironment(options.filePath ?? null, parsed.directives, options.environment ?? null, options.environmentLocked === true);
   const environment = resolved2.environment;
   const isDeclarationFile = options.filePath !== void 0 && isDeclarationPath(options.filePath);
   const checked = check(parsed.program, mode, environment, {
@@ -22050,7 +22419,7 @@ function compile(source, options = {}) {
     return { ...shared, code: null, requiredHelpers: [], lines: [] };
   }
   const references = reachedNames(checked.references, options.projectReferences);
-  const emitted = emit2(parsed.program, checked.types, references, checked.generatedMembers, 0, checked.staticAccess);
+  const emitted2 = emit2(parsed.program, checked.types, references, checked.generatedMembers, 0, checked.staticAccess);
   const preserved = emitPreservingSource({
     source,
     program: parsed.program,
@@ -22063,7 +22432,7 @@ function compile(source, options = {}) {
     staticAccess: checked.staticAccess,
     development: options.development === true
   });
-  const required = new Set(emitted.requiredHelpers);
+  const required = new Set(emitted2.requiredHelpers);
   for (const name of checked.references) {
     const helper = checked.declaredGlobals.has(name) ? null : helperForGlobal(name);
     if (helper !== null) {
@@ -22072,9 +22441,9 @@ function compile(source, options = {}) {
   }
   return {
     ...shared,
-    code: preserved?.code ?? emitted.code,
+    code: preserved?.code ?? emitted2.code,
     requiredHelpers: expandHelpers(required).sort(),
-    lines: preserved?.lines ?? emitted.lines
+    lines: preserved?.lines ?? emitted2.lines
   };
 }
 
@@ -22291,11 +22660,20 @@ function baseKey(context) {
   const contracts = context.contracts.map((contract) => serializeAbi(contract)).join(";");
   return `${optionsKey(context.options)}|${mode}|${JSON.stringify(context.project.globals)}|${[...context.references].sort().join(",")}|${hashString(contracts)}`;
 }
+function isVisible(environment, isLibrary2, provider) {
+  return canReference(environment, provider.environment) && (!isLibrary2 || provider.isLibrary);
+}
+function scopeKey(environment, isLibrary2) {
+  return `${environment}|${isLibrary2 ? "library" : "project"}`;
+}
+var SCOPES = [false, true];
 function environmentKeys(collected) {
-  const keys = {};
+  const keys = /* @__PURE__ */ new Map();
   for (const environment of ALL_ENVIRONMENTS) {
-    const visible = collected.filter((entry) => canReference(environment, entry.environment));
-    keys[environment] = hashString(visible.map((entry) => `${entry.path}=${entry.fingerprint}`).join(";"));
+    for (const isLibrary2 of SCOPES) {
+      const visible = collected.filter((entry) => isVisible(environment, isLibrary2, entry));
+      keys.set(scopeKey(environment, isLibrary2), hashString(visible.map((entry) => `${entry.path}=${entry.fingerprint}`).join(";")));
+    }
   }
   return keys;
 }
@@ -22303,15 +22681,19 @@ function createResolver(collected) {
   const visible = /* @__PURE__ */ new Map();
   const merged = /* @__PURE__ */ new Map();
   for (const environment of ALL_ENVIRONMENTS) {
-    const entries3 = collected.filter((entry) => canReference(environment, entry.environment) && !declaresNothing(entry.declarations));
-    visible.set(environment, entries3);
-    merged.set(environment, mergeAmbient(entries3.map((entry) => entry.declarations)));
+    for (const isLibrary2 of SCOPES) {
+      const key = scopeKey(environment, isLibrary2);
+      const entries3 = collected.filter((entry) => isVisible(environment, isLibrary2, entry) && !declaresNothing(entry.declarations));
+      visible.set(key, entries3);
+      merged.set(key, mergeAmbient(entries3.map((entry) => entry.declarations)));
+    }
   }
   return (entry) => {
+    const key = scopeKey(entry.environment, entry.isLibrary);
     if (declaresNothing(entry.declarations)) {
-      return merged.get(entry.environment) ?? EMPTY_AMBIENT;
+      return merged.get(key) ?? EMPTY_AMBIENT;
     }
-    const entries3 = visible.get(entry.environment) ?? [];
+    const entries3 = visible.get(key) ?? [];
     return mergeAmbient(entries3.filter((candidate) => candidate.path !== entry.path).map((candidate) => candidate.declarations));
   };
 }
@@ -22321,7 +22703,7 @@ function createAmbientScope(collected, context) {
   const fallback = environmentKeys(collected);
   return {
     graph,
-    keyFor: (entry) => hashString(`${base}|${graph.keyOf(entry.path) ?? fallback[entry.environment]}`),
+    keyFor: (entry) => hashString(`${base}|${graph.keyOf(entry.path) ?? fallback.get(scopeKey(entry.environment, entry.isLibrary)) ?? ""}`),
     resolve: createResolver(collected)
   };
 }
@@ -22366,13 +22748,96 @@ function validateContributions(modules) {
   }
   return diagnostics;
 }
+var LIBRARY_COLLISION = "project-library-collision";
+var LIBRARY_SHADOWS_API = "project-library-shadows-api";
+function describeOwner(owner) {
+  return owner.module.origin === null ? `the project file "${owner.module.path}"` : `the library "${owner.module.origin.package}"`;
+}
+function describeSides(sides) {
+  return sides.length > 1 ? '"shared"' : `"${sides[0] ?? "shared"}"`;
+}
+function collisionDiagnostic(collision) {
+  const { name, intruder, other } = collision;
+  const subject = `"${name}" is declared by ${describeOwner(intruder)} and by ${describeOwner(other)} on the ${describeSides(collision.sides)} side`;
+  const message = `${subject}. MTA keeps one global per name, so one silently replaces the other. Stop using one of them.`;
+  return { path: intruder.module.path, diagnostic: createDiagnostic("project", LIBRARY_COLLISION, message, intruder.position) };
+}
+function recordCollision(collisions, name, side2, first, next) {
+  if (first.module.origin === null && next.module.origin === null) {
+    return;
+  }
+  const intruder = next.module.origin === null ? first : next;
+  const other = intruder === next ? first : next;
+  const key = `${name}:${intruder.module.path}:${other.module.path}`;
+  const found = collisions.get(key);
+  if (found === void 0) {
+    collisions.set(key, { name, intruder, other, sides: [side2] });
+    return;
+  }
+  found.sides.push(side2);
+}
+function validateLibraryGlobals(modules) {
+  const owners = /* @__PURE__ */ new Map();
+  const collisions = /* @__PURE__ */ new Map();
+  if (!modules.some((module) => module.origin !== null)) {
+    return [];
+  }
+  for (const module of modules) {
+    for (const [name, position2] of module.declaredGlobals) {
+      for (const side2 of sidesOf(module.environment)) {
+        const key = `${side2}:${name}`;
+        const first = owners.get(key);
+        if (first === void 0) {
+          owners.set(key, { module, position: position2 });
+          continue;
+        }
+        recordCollision(collisions, name, side2, first, { module, position: position2 });
+      }
+    }
+  }
+  return [...collisions.values()].map(collisionDiagnostic);
+}
+function shadowsApi(name, sides) {
+  return sides.find((side2) => builtinSymbols(side2).has(name)) ?? null;
+}
+function validateLibraryApiShadowing(modules) {
+  const diagnostics = [];
+  for (const module of modules) {
+    if (module.origin === null) {
+      continue;
+    }
+    for (const [name, position2] of module.declaredGlobals) {
+      const side2 = shadowsApi(name, sidesOf(module.environment));
+      if (side2 === null) {
+        continue;
+      }
+      const subject = `The library "${module.origin.package}" declares "${name}", which the MTA API defines for the "${side2}" side`;
+      const message = `${subject}. Every file in the resource sees the library's version. Keep it only if the library means to wrap it.`;
+      diagnostics.push({ path: module.path, diagnostic: createDiagnostic("project", LIBRARY_SHADOWS_API, message, position2, "warning") });
+    }
+  }
+  return diagnostics;
+}
+function projectReferenceDiagnostic(module, symbol, position2) {
+  const subject = `"${symbol.name}" is declared by the project file "${symbol.path}" and cannot be used from the library "${module.origin?.package ?? ""}"`;
+  const message = `${subject}. A library sees only its own files and the libraries it requires.`;
+  return { path: module.path, diagnostic: createDiagnostic("project", "project-library-project-reference", message, position2) };
+}
 function validateModuleReferences(modules) {
   const symbols = buildSymbolTable(modules);
+  const libraries = new Set(modules.filter((module) => module.origin !== null).map((module) => module.path));
   const diagnostics = [];
   for (const module of modules) {
     for (const [name, position2] of module.externalReferences) {
       const symbol = symbols.get(name);
-      if (symbol === void 0 || symbol.path === module.path || canReference(module.environment, symbol.environment)) {
+      if (symbol === void 0 || symbol.path === module.path) {
+        continue;
+      }
+      if (module.origin !== null && !libraries.has(symbol.path)) {
+        diagnostics.push(projectReferenceDiagnostic(module, symbol, position2));
+        continue;
+      }
+      if (canReference(module.environment, symbol.environment)) {
         continue;
       }
       diagnostics.push(referenceDiagnostic(module, symbol, position2));
@@ -22389,6 +22854,7 @@ function compileModule(file, ambient, context) {
   const result = compile(file.source, {
     filePath: file.path,
     ...file.environment === void 0 ? {} : { environment: file.environment },
+    environmentLocked: file.origin !== void 0,
     ambient,
     contracts: context.contracts,
     project: isTestPath(file.path) ? context.testProject : context.project,
@@ -22398,6 +22864,7 @@ function compileModule(file, ambient, context) {
   });
   return {
     path: file.path,
+    origin: file.origin ?? null,
     environment: result.environment,
     isDeclaration: isDeclarationPath(file.path),
     code: result.code,
@@ -22427,7 +22894,7 @@ function createProjectCache() {
   const declarationCache = /* @__PURE__ */ new Map();
   const moduleCache = /* @__PURE__ */ new Map();
   function declarationsFor(file, options, reused) {
-    const hash = hashString(`${file.environment ?? ""}|${optionsKey(options)}|${file.source}`);
+    const hash = hashString(`${file.environment ?? ""}|${file.origin?.root ?? ""}|${optionsKey(options)}|${file.source}`);
     const cached = declarationCache.get(file.path);
     if (cached !== void 0 && cached.hash === hash) {
       reused.count += 1;
@@ -22436,11 +22903,13 @@ function createProjectCache() {
     const result = compile(file.source, {
       filePath: file.path,
       ...file.environment === void 0 ? {} : { environment: file.environment },
+      environmentLocked: file.origin !== void 0,
       compilerOptions: options,
       emitCode: false
     });
     const entry = {
       path: file.path,
+      isLibrary: file.origin !== void 0,
       hash,
       environment: result.environment,
       declarations: result.declarations,
@@ -22491,7 +22960,8 @@ function createProjectCache() {
       });
       const references = validateModuleReferences(modules);
       const contributions = validateContributions(modules);
-      const collectedDiagnostics = sortFileDiagnostics([...flattenDiagnostics(modules), ...references, ...contributions]);
+      const libraries = [...validateLibraryGlobals(modules), ...validateLibraryApiShadowing(modules)];
+      const collectedDiagnostics = sortFileDiagnostics([...flattenDiagnostics(modules), ...references, ...contributions, ...libraries]);
       const diagnostics = compilerOptions.warningsAsErrors ? promoteWarnings(collectedDiagnostics) : collectedDiagnostics;
       const paths = new Set(files.map((file) => file.path));
       prune(declarationCache, paths);
@@ -22519,7 +22989,7 @@ function helperList(config, inputs) {
   const helpers = [...config.helpers, "env"];
   return helpers.sort();
 }
-function resourceOptions(config, inputs, minMtaVersion, developmentLogs, layout) {
+function resourceOptions(config, inputs, minMtaVersion, developmentLogs, layout, libraryFiles) {
   const options = {
     oop: config.compilerOptions.oop,
     dependencies: config.dependencies,
@@ -22528,6 +22998,7 @@ function resourceOptions(config, inputs, minMtaVersion, developmentLogs, layout)
     configuration: inputs.configuration,
     environmentFile: config.environment.file,
     loadOrder: config.loadOrder,
+    libraryFiles,
     minMtaVersion,
     developmentLogs,
     layout,
@@ -22570,9 +23041,11 @@ function runCompile(root, config, options = {}) {
   const excluded = [config.outDir, config.contracts];
   const sources = discoverSources(root, config.sources, excluded);
   const inputs = readProjectInputs(root, { assets: config.assets, environment: config.environment, excluded });
-  const files = [...sources.files, ...options.additionalFiles ?? []].sort((left, right) => left.path.localeCompare(right.path));
+  const libraries = resolveLibraries(root, config.libraries);
+  const projectFiles = [...sources.files, ...options.additionalFiles ?? []].sort((left, right) => left.path.localeCompare(right.path));
+  const files = [...libraries.files, ...projectFiles];
   const contracts = readDependencyContracts(root, config);
-  const diagnostics = [...sources.diagnostics, ...inputs.diagnostics, ...contracts.diagnostics];
+  const diagnostics = [...sources.diagnostics, ...inputs.diagnostics, ...libraries.diagnostics, ...contracts.diagnostics];
   if (hasCliErrors(diagnostics)) {
     tracker.end("failed");
     return {
@@ -22601,7 +23074,7 @@ function runCompile(root, config, options = {}) {
   tracker.begin("assembly");
   const assembly = assembleResource(
     project,
-    resourceOptions(config, inputs, options.minMtaVersion ?? null, options.developmentLogs ?? null, options.layout ?? "tree"),
+    resourceOptions(config, inputs, options.minMtaVersion ?? null, options.developmentLogs ?? null, options.layout ?? "tree", libraries.verbatim),
     (step) => {
       if (step === "assembly") {
         tracker.begin("manifest");
@@ -22626,8 +23099,8 @@ function runCompile(root, config, options = {}) {
 }
 
 // src/build/resource-map-file.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync7, readdirSync as readdirSync2, unlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname3, isAbsolute as isAbsolute3, join as join4, posix, relative as relative2, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync8, readdirSync as readdirSync2, unlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join4, posix, relative as relative2, resolve as resolve10 } from "node:path";
 var RESOURCE_MAP_SUFFIX = ".luam-map.json";
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -22692,28 +23165,28 @@ function reason(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function resourceMapPath(root, config) {
-  return resolve9(root, config.outDir, `${config.name}${RESOURCE_MAP_SUFFIX}`);
+  return resolve10(root, config.outDir, `${config.name}${RESOURCE_MAP_SUFFIX}`);
 }
 function explicitResourceMapPath(root, path) {
-  return isAbsolute3(path) ? path : resolve9(root, path);
+  return isAbsolute3(path) ? path : resolve10(root, path);
 }
 function writeResourceMap(root, config, map) {
   const path = resourceMapPath(root, config);
   if (map === null) {
-    if (existsSync5(path)) {
+    if (existsSync6(path)) {
       unlinkSync(path);
     }
     return;
   }
   mkdirSync3(dirname3(path), { recursive: true });
   const content = serializeResourceMap(map);
-  if (!existsSync5(path) || readFileSync7(path, "utf8") !== content) {
+  if (!existsSync6(path) || readFileSync8(path, "utf8") !== content) {
     writeFileSync4(path, content, "utf8");
   }
 }
 function readResourceMap(path) {
   try {
-    const value = JSON.parse(readFileSync7(path, "utf8"));
+    const value = JSON.parse(readFileSync8(path, "utf8"));
     if (isObject(value) && Number.isInteger(value.version) && value.version !== RESOURCE_MAP_VERSION) {
       return { map: null, error: `Resource map version ${String(value.version)} is not supported.` };
     }
@@ -22747,7 +23220,7 @@ function collectResourceMaps(directory, found) {
   }
 }
 function discoverResourceMap(root) {
-  if (!existsSync5(root)) {
+  if (!existsSync6(root)) {
     return { path: null, candidates: [] };
   }
   const found = [];
@@ -22757,8 +23230,8 @@ function discoverResourceMap(root) {
 }
 
 // src/build/resource-writer.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname4, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve11 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve12 } from "node:path";
 
 // src/build/lua-tokens.ts
 var WHITESPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\r", "\v", "\f"]);
@@ -22961,8 +23434,8 @@ function minifyLuaFiles(files) {
 }
 
 // src/build/resource-prune.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, rmdirSync, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join5, relative as relative3, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync3, rmdirSync, unlinkSync as unlinkSync2 } from "node:fs";
+import { join as join5, relative as relative3, resolve as resolve11 } from "node:path";
 var GENERATED_MANIFEST = "meta.xml";
 var GENERATED_EXTENSION = ".lua";
 var PROTECTED = /* @__PURE__ */ new Set([ENVIRONMENT_FILE, ".env.local"]);
@@ -22979,17 +23452,17 @@ function isGenerated(relativePath2, options) {
   return options.generatedRoots.some((root) => isUnderRoot(relativePath2, root));
 }
 function removeEmptyDirectories(targetDir, directory) {
-  if (resolve10(directory) === resolve10(targetDir)) {
+  if (resolve11(directory) === resolve11(targetDir)) {
     return;
   }
   if (readdirSync3(directory).length > 0) {
     return;
   }
   rmdirSync(directory);
-  removeEmptyDirectories(targetDir, resolve10(directory, ".."));
+  removeEmptyDirectories(targetDir, resolve11(directory, ".."));
 }
 function pruneResource(targetDir, keep, options) {
-  if (!existsSync6(targetDir)) {
+  if (!existsSync7(targetDir)) {
     return [];
   }
   const removed = [];
@@ -23039,7 +23512,7 @@ function resourceFiles(build) {
   return files;
 }
 function resolveInside(targetDir, path) {
-  const absolute = resolve11(targetDir, path);
+  const absolute = resolve12(targetDir, path);
   const inside = relative4(targetDir, absolute);
   if (inside.startsWith("..") || isAbsolute4(inside)) {
     throw new Error(`The generated file "${path}" resolves outside the resource directory "${targetDir}".`);
@@ -23047,7 +23520,7 @@ function resolveInside(targetDir, path) {
   return absolute;
 }
 function writeIfChanged(absolute, content) {
-  if (existsSync7(absolute) && readFileSync8(absolute).equals(content)) {
+  if (existsSync8(absolute) && readFileSync9(absolute).equals(content)) {
     return false;
   }
   mkdirSync4(dirname4(absolute), { recursive: true });
@@ -23059,7 +23532,7 @@ function writeEnvironmentFile(targetDir, template) {
     return false;
   }
   const absolute = resolveInside(targetDir, ENVIRONMENT_FILE);
-  if (existsSync7(absolute)) {
+  if (existsSync8(absolute)) {
     return false;
   }
   mkdirSync4(dirname4(absolute), { recursive: true });
@@ -23087,7 +23560,7 @@ function writeResource(targetDir, build, options) {
     advance(path);
   }
   for (const asset of build.assets) {
-    if (writeIfChanged(resolveInside(targetDir, asset.path), readFileSync8(resolve11(options.root, asset.source)))) {
+    if (writeIfChanged(resolveInside(targetDir, asset.path), readFileSync9(resolve12(options.root, asset.source)))) {
       written.push(asset.path);
       advance(asset.path);
       continue;
@@ -23117,7 +23590,7 @@ function destinationRoot(mapping) {
 }
 function generatedRoots(config) {
   const roots = config.assets.map(destinationRoot).filter((root) => root.length > 0);
-  return [.../* @__PURE__ */ new Set([...roots, LIBRARY_DIRECTORY])];
+  return [.../* @__PURE__ */ new Set([...roots, LIBRARY_DIRECTORY, LIBRARIES_DIRECTORY])];
 }
 function trackedWriteOptions(root, config, environmentTemplate, tracker) {
   return {
@@ -23204,16 +23677,16 @@ function reportBuildOutcome(context, outcome, action) {
 }
 
 // src/commands/resource-targets.ts
-import { isAbsolute as isAbsolute5, resolve as resolve12 } from "node:path";
+import { isAbsolute as isAbsolute5, resolve as resolve13 } from "node:path";
 function resolveBuildTarget(root, config) {
-  return resolve12(root, config.outDir, config.name);
+  return resolve13(root, config.outDir, config.name);
 }
 function resolveServerTarget(root, config) {
   if (config.serverPath === null) {
     return null;
   }
-  const serverRoot = isAbsolute5(config.serverPath) ? config.serverPath : resolve12(root, config.serverPath);
-  return resolve12(serverRoot, config.resourcesDir, config.name);
+  const serverRoot = isAbsolute5(config.serverPath) ? config.serverPath : resolve13(root, config.serverPath);
+  return resolve13(serverRoot, config.resourcesDir, config.name);
 }
 
 // src/reporting/progress-renderer.ts
@@ -23258,7 +23731,7 @@ function createProgressRenderer(reporter, options = {}) {
     paint(reporter.style.eraseLine());
     dirty = false;
   }
-  function render2(event) {
+  function render3(event) {
     const columns = Math.max(20, reporter.capability.columns - 1);
     const line2 = activeLine(reporter, event);
     paint(`${reporter.style.eraseLine()}${line2.slice(0, columns)}`);
@@ -23278,7 +23751,7 @@ function createProgressRenderer(reporter, options = {}) {
     if (frames > 0 && now() - lastPaintAt < throttleMs) {
       return;
     }
-    render2(event);
+    render3(event);
   }
   return {
     listen: (event) => {
@@ -23321,6 +23794,7 @@ async function runBuildCommand(context, options = {}) {
   if (outcome.build === null) {
     reportBuildOutcome(context, outcome, "Build");
     reportPhaseTimings(reporter, tracker.durations(), totalDuration(tracker.durations()));
+    options.onOutcome?.(outcome);
     return EXIT_DIAGNOSTICS;
   }
   const target = resolveBuildTarget(context.root, context.config);
@@ -23333,6 +23807,7 @@ async function runBuildCommand(context, options = {}) {
     tracker.end("failed");
     renderer.clear();
     reporter.error(`Build wrote nothing to "${target}". ${error instanceof Error ? error.message : String(error)}`);
+    options.onOutcome?.(outcome);
     return EXIT_DIAGNOSTICS;
   }
   writeResourceMap(context.root, context.config, writtenMap(outcome.map, minify));
@@ -23345,13 +23820,93 @@ async function runBuildCommand(context, options = {}) {
   const counts = `${result.unchanged} unchanged, ${result.removed.length} removed`;
   reporter.info(`Wrote ${pluralize(result.written.length, "file")} to "${target}" (${counts}).`);
   reportPhaseTimings(reporter, tracker.durations(), totalDuration(tracker.durations()));
+  options.onOutcome?.(outcome);
   return EXIT_OK;
 }
 
+// src/reporting/json-report.ts
+var REPORT_SCHEMA_VERSION = 1;
+function fromCli(diagnostic) {
+  return { path: null, line: null, column: null, endLine: null, endColumn: null, ...diagnostic };
+}
+function fromFile(entry) {
+  const { position: position2, end, severity, code, message } = entry.diagnostic;
+  return {
+    path: entry.path,
+    line: position2.line,
+    column: position2.column,
+    endLine: end === null ? null : end.line,
+    endColumn: end === null ? null : end.column,
+    severity,
+    code,
+    message
+  };
+}
+function buildReport(command, outcome, success) {
+  const cli = countCliDiagnostics(outcome.diagnostics);
+  const files = countFileDiagnostics(outcome.fileDiagnostics);
+  return {
+    version: REPORT_SCHEMA_VERSION,
+    luam: VERSION,
+    command,
+    success,
+    diagnostics: [...outcome.diagnostics.map(fromCli), ...outcome.fileDiagnostics.map(fromFile)],
+    summary: {
+      errors: cli.errors + files.errors,
+      warnings: cli.warnings + files.warnings,
+      files: outcome.fileCount,
+      durationMs: Math.round(outcome.durationMs)
+    }
+  };
+}
+function writeReport(logger, report2) {
+  logger.info(JSON.stringify(report2));
+}
+
+// src/reporting/silent.ts
+function createSilentLogger() {
+  return {
+    info: () => void 0,
+    warn: () => void 0,
+    error: () => void 0
+  };
+}
+function createSilentReporter() {
+  return createReporter(createSilentLogger(), PLAIN_CAPABILITY, () => void 0);
+}
+
+// src/commands/json-command.ts
+function emptyReport(command, success) {
+  return {
+    version: REPORT_SCHEMA_VERSION,
+    luam: VERSION,
+    command,
+    success,
+    diagnostics: [],
+    summary: { errors: success ? 0 : 1, warnings: 0, files: 0, durationMs: 0 }
+  };
+}
+function captureJson(context) {
+  let captured = null;
+  return {
+    context: { ...context, logger: createSilentLogger(), reporter: createSilentReporter() },
+    outcome: () => captured,
+    record: (outcome) => {
+      captured = outcome;
+    }
+  };
+}
+function emitJson(logger, command, capture, code) {
+  const outcome = capture.outcome();
+  const success = code === EXIT_OK;
+  writeReport(logger, outcome === null ? emptyReport(command, success) : buildReport(command, outcome, success));
+  return code;
+}
+
 // src/cli/registry/build-registration.ts
 function registerBuildCommand(program2, runtime) {
   const command = program2.command("build").description("Compile the project and write the resource to the output directory.");
-  addMinifyOptions(addLayoutOptions(addProjectOptions(command))).addOption(noMapOption()).addOption(offlineOption());
+  addMinifyOptions(addLayoutOptions(addProjectOptions(command))).addOption(noMapOption()).addOption(offlineOption()).addOption(jsonOption());
   command.action(async (options) => {
     const project = createProjectContext(runtime, "build", options);
     if (project.context === null) {
@@ -23359,39 +23914,236 @@ function registerBuildCommand(program2, runtime) {
       return;
     }
     const bundled = options.bundle ?? project.context.config.output.bundle;
-    runtime.exitCode = await runBuildCommand(project.context, {
+    const build = {
       layout: bundled ? "bundle" : "tree",
       map: options.map && project.context.config.output.map,
       minify: options.minify ?? project.context.config.output.minify
-    });
+    };
+    if (options.json !== true) {
+      runtime.exitCode = await runBuildCommand(project.context, build);
+      return;
+    }
+    const capture = captureJson(project.context);
+    runtime.exitCode = emitJson(runtime.logger, "build", capture, await runBuildCommand(capture.context, { ...build, onOutcome: capture.record }));
+  });
+}
+
+// src/reporting/rebuild-separator.ts
+var RULE_WIDTH = 40;
+function formatTimestamp(at) {
+  return at.toISOString().slice(11, 19);
+}
+function reportRebuildSeparator(reporter, at = /* @__PURE__ */ new Date()) {
+  const rule = (reporter.capability.unicode ? "\u2500" : "-").repeat(RULE_WIDTH);
+  reporter.raw("");
+  reporter.detail(`${rule} rebuild at ${formatTimestamp(at)}`);
+}
+
+// src/watch/abort-wait.ts
+function untilAborted(signal) {
+  return new Promise((resolveLoop) => {
+    if (signal?.aborted === true) {
+      resolveLoop();
+      return;
+    }
+    const stop = () => {
+      process.off("SIGINT", stop);
+      signal?.removeEventListener("abort", stop);
+      resolveLoop();
+    };
+    if (signal !== null) {
+      signal.addEventListener("abort", stop, { once: true });
+    }
+    process.on("SIGINT", stop);
   });
 }
 
+// src/watch/manifest-watcher.ts
+import { existsSync as existsSync10, watch as watch2 } from "node:fs";
+
+// src/watch/source-watcher.ts
+import { existsSync as existsSync9, watch } from "node:fs";
+import { relative as relative5, resolve as resolve14 } from "node:path";
+var DEFAULT_DEBOUNCE_MS = 120;
+function watchSources(root, sources, onChange, debounceMs = DEFAULT_DEBOUNCE_MS) {
+  const resolver = createSourceResolver(sources);
+  const watchers = [];
+  let timer = null;
+  const schedule = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      onChange();
+    }, debounceMs);
+  };
+  const isWatched = (directory, filename) => {
+    const path = normalizePattern(relative5(root, resolve14(directory, filename)));
+    return path.endsWith(SOURCE_EXTENSION) && resolver.resolve(path).matches.length > 0;
+  };
+  for (const entry of resolver.roots) {
+    const absolute = resolve14(root, entry);
+    if (!existsSync9(absolute)) {
+      continue;
+    }
+    watchers.push(
+      watch(absolute, { recursive: true }, (_event, filename) => {
+        if (filename !== null && isWatched(absolute, filename.toString())) {
+          schedule();
+        }
+      })
+    );
+  }
+  return {
+    close: () => {
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      for (const watcher of watchers) {
+        watcher.close();
+      }
+    }
+  };
+}
+function watchedRoots(sources) {
+  return createSourceResolver(sources).roots;
+}
+
+// src/watch/manifest-watcher.ts
+function watchManifest(path, onChange, debounceMs = DEFAULT_DEBOUNCE_MS) {
+  let timer = null;
+  let watcher = null;
+  const clear = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  if (existsSync10(path)) {
+    watcher = watch2(path, () => {
+      clear();
+      timer = setTimeout(() => {
+        timer = null;
+        onChange();
+      }, debounceMs);
+    });
+  }
+  return {
+    close: () => {
+      clear();
+      watcher?.close();
+    }
+  };
+}
+
 // src/commands/check-command.ts
-function runCheckCommand(context) {
+function runCheckCommand(context, options = {}) {
   const reporter = commandReporter(context);
   const renderer = createProgressRenderer(reporter);
   const tracker = createPhaseTracker(renderer.listen);
-  const outcome = runCompile(context.root, context.config, { tracker });
+  const cache3 = options.cache;
+  const outcome = runCompile(context.root, context.config, cache3 === void 0 ? { tracker } : { tracker, cache: cache3 });
   renderer.clear();
   const passed = reportBuildOutcome(context, outcome, "Check");
   reportPhaseTimings(reporter, tracker.durations(), totalDuration(tracker.durations()));
+  options.onOutcome?.(outcome);
   return passed ? EXIT_OK : EXIT_DIAGNOSTICS;
 }
+async function runCheckWatch(context, options) {
+  const reporter = commandReporter(context);
+  let config = context.config;
+  let cache3 = createProjectCache();
+  const sources = [];
+  let running = false;
+  let queued = false;
+  const announce = () => {
+    const roots = watchedRoots(config.sources).map((entry) => `"${entry.length === 0 ? "." : entry}"`);
+    reporter.info(`Watching ${roots.join(", ")} for changes. Press Ctrl+C to stop.`);
+  };
+  const recheck = () => {
+    if (running) {
+      queued = true;
+      return;
+    }
+    running = true;
+    do {
+      queued = false;
+      reportRebuildSeparator(reporter);
+      runCheckCommand({ ...context, config }, { cache: cache3 });
+    } while (queued);
+    running = false;
+  };
+  const listen = () => {
+    for (const watcher of sources.splice(0)) {
+      watcher.close();
+    }
+    sources.push(watchSources(context.root, config.sources, recheck));
+  };
+  const reconfigure = () => {
+    const reloaded = options.reload();
+    if (reloaded !== null) {
+      config = reloaded;
+    }
+    cache3 = createProjectCache();
+    listen();
+    recheck();
+    announce();
+  };
+  runCheckCommand(context, { cache: cache3 });
+  listen();
+  const manifest = watchManifest(options.manifestPath, reconfigure);
+  announce();
+  await untilAborted(options.signal);
+  manifest.close();
+  for (const watcher of sources.splice(0)) {
+    watcher.close();
+  }
+  return EXIT_OK;
+}
 
 // src/cli/registry/check-registration.ts
 function registerCheckCommand(program2, runtime) {
   const command = program2.command("check").description("Compile the project and report diagnostics without writing files.");
-  addProjectOptions(command);
-  command.action((options) => {
+  addProjectOptions(command).addOption(new Option("--watch", "Keep the command running and re-check on source changes.")).addOption(new Option("--no-watch", "Run the command once and exit.")).addOption(jsonOption());
+  command.action(async (options) => {
+    if (options.json === true && options.watch === true) {
+      runtime.reporter.error('"--json" writes one document and "--watch" never stops. Run "luam check --json" without "--watch".');
+      runtime.exitCode = EXIT_USAGE;
+      return;
+    }
     const project = createProjectContext(runtime, "check", options);
-    runtime.exitCode = project.context === null ? project.error : runCheckCommand(project.context);
+    if (project.context === null) {
+      runtime.exitCode = project.error;
+      return;
+    }
+    if (options.json === true) {
+      const capture = captureJson(project.context);
+      runtime.exitCode = emitJson(runtime.logger, "check", capture, runCheckCommand(capture.context, { onOutcome: capture.record }));
+      return;
+    }
+    if (options.watch !== true) {
+      runtime.exitCode = runCheckCommand(project.context);
+      return;
+    }
+    const root = project.context.root;
+    const manifestPath = resolveManifestPath(root, options.manifest ?? null);
+    const reload = () => {
+      const loaded = loadManifest(root, { path: options.manifest ?? null, mode: manifestMode("check"), env: runtime.env });
+      reportManifestDiagnostics(runtime.reporter, loaded.path, loaded.source, loaded.diagnostics);
+      if (loaded.config === null) {
+        runtime.reporter.error(`Manifest "${loaded.path}" is invalid. Keeping the previous configuration.`);
+      }
+      return loaded.config;
+    };
+    runtime.exitCode = await runCheckWatch(project.context, { signal: runtime.overrides.signal ?? null, manifestPath, reload });
   });
 }
 
 // src/commands/config-command.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname5, relative as relative5, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname5, relative as relative6, resolve as resolve15 } from "node:path";
 
 // ../compiler/src/project/config-reader.ts
 var Reader = class {
@@ -23605,33 +24357,33 @@ function isGeneratedDeclaration(text) {
 var DEFAULT_CONFIG_SOURCE = "config.lua";
 var DEFAULT_CONFIG_OUTPUT = "config.d.luam";
 function escapes(root, path) {
-  const inside = relative5(root, path);
-  return inside.startsWith("..") || resolve13(root, inside) !== path;
+  const inside = relative6(root, path);
+  return inside.startsWith("..") || resolve15(root, inside) !== path;
 }
 function readSource2(root, source, reporter) {
-  const path = resolve13(root, source);
+  const path = resolve15(root, source);
   if (escapes(root, path)) {
     reporter.error(`Config declarations read only inside the project, but "${source}" points outside it.`);
     return null;
   }
-  if (!existsSync8(path)) {
+  if (!existsSync11(path)) {
     reporter.error(`Config declarations found no file at "${source}".`);
     return null;
   }
   try {
-    return readFileSync9(path, "utf8");
+    return readFileSync10(path, "utf8");
   } catch {
     reporter.error(`Config declarations could not read "${source}".`);
     return null;
   }
 }
 function writable(root, out, reporter) {
-  const path = resolve13(root, out);
+  const path = resolve15(root, out);
   if (escapes(root, path)) {
     reporter.error(`Config declarations write only inside the project, but "${out}" points outside it.`);
     return null;
   }
-  if (existsSync8(path) && !isGeneratedDeclaration(readFileSync9(path, "utf8"))) {
+  if (existsSync11(path) && !isGeneratedDeclaration(readFileSync10(path, "utf8"))) {
     reporter.error(`"${out}" was not generated by this command and was left alone. Choose another path with --out.`);
     return null;
   }
@@ -23764,85 +24516,7 @@ function createEnsureRunner(context, options = {}) {
   };
 }
 
-// src/reporting/rebuild-separator.ts
-var RULE_WIDTH = 40;
-function formatTimestamp(at) {
-  return at.toISOString().slice(11, 19);
-}
-function reportRebuildSeparator(reporter, at = /* @__PURE__ */ new Date()) {
-  const rule = (reporter.capability.unicode ? "\u2500" : "-").repeat(RULE_WIDTH);
-  reporter.raw("");
-  reporter.detail(`${rule} rebuild at ${formatTimestamp(at)}`);
-}
-
-// src/watch/source-watcher.ts
-import { existsSync as existsSync9, watch } from "node:fs";
-import { relative as relative6, resolve as resolve14 } from "node:path";
-var DEFAULT_DEBOUNCE_MS = 120;
-function watchSources(root, sources, onChange, debounceMs = DEFAULT_DEBOUNCE_MS) {
-  const resolver = createSourceResolver(sources);
-  const watchers = [];
-  let timer = null;
-  const schedule = () => {
-    if (timer !== null) {
-      clearTimeout(timer);
-    }
-    timer = setTimeout(() => {
-      timer = null;
-      onChange();
-    }, debounceMs);
-  };
-  const isWatched = (directory, filename) => {
-    const path = normalizePattern(relative6(root, resolve14(directory, filename)));
-    return path.endsWith(SOURCE_EXTENSION) && resolver.resolve(path).matches.length > 0;
-  };
-  for (const entry of resolver.roots) {
-    const absolute = resolve14(root, entry);
-    if (!existsSync9(absolute)) {
-      continue;
-    }
-    watchers.push(
-      watch(absolute, { recursive: true }, (_event, filename) => {
-        if (filename !== null && isWatched(absolute, filename.toString())) {
-          schedule();
-        }
-      })
-    );
-  }
-  return {
-    close: () => {
-      if (timer !== null) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      for (const watcher of watchers) {
-        watcher.close();
-      }
-    }
-  };
-}
-function watchedRoots(sources) {
-  return createSourceResolver(sources).roots;
-}
-
 // src/commands/ensure-command.ts
-function untilAborted(signal) {
-  return new Promise((resolveLoop) => {
-    if (signal?.aborted === true) {
-      resolveLoop();
-      return;
-    }
-    const stop = () => {
-      process.off("SIGINT", stop);
-      signal?.removeEventListener("abort", stop);
-      resolveLoop();
-    };
-    if (signal !== null) {
-      signal.addEventListener("abort", stop, { once: true });
-    }
-    process.on("SIGINT", stop);
-  });
-}
 async function watchLoop(context, runner, options) {
   const reporter = commandReporter(context);
   let running = false;
@@ -24005,12 +24679,12 @@ function parseMtaLogLine(line2, activeResource, fallback = /* @__PURE__ */ new D
 }
 
 // src/logging/server-log-follower.ts
-import { closeSync, existsSync as existsSync10, openSync, readSync, statSync as statSync4 } from "node:fs";
-import { isAbsolute as isAbsolute6, resolve as resolve15 } from "node:path";
+import { closeSync, existsSync as existsSync12, openSync, readSync, statSync as statSync4 } from "node:fs";
+import { isAbsolute as isAbsolute6, resolve as resolve16 } from "node:path";
 var DEFAULT_POLL_INTERVAL_MS = 100;
 function resolveServerLogPath(root, serverPath) {
-  const server = isAbsolute6(serverPath) ? serverPath : resolve15(root, serverPath);
-  return resolve15(server, "mods/deathmatch/logs/server.log");
+  const server = isAbsolute6(serverPath) ? serverPath : resolve16(root, serverPath);
+  return resolve16(server, "mods/deathmatch/logs/server.log");
 }
 function identity(path) {
   const stats = statSync4(path);
@@ -24035,7 +24709,7 @@ function followServerLog(path, onLine, options = {}) {
   let initialized = false;
   let closed = false;
   const poll = () => {
-    if (closed || !existsSync10(path)) {
+    if (closed || !existsSync12(path)) {
       return;
     }
     try {
@@ -24151,7 +24825,7 @@ function connectServerConsoleInput(input, output, interrupt) {
 
 // src/server/server-executable-resolver.ts
 import { realpathSync, statSync as statSync5 } from "node:fs";
-import { isAbsolute as isAbsolute7, relative as relative7, resolve as resolve16 } from "node:path";
+import { isAbsolute as isAbsolute7, relative as relative7, resolve as resolve17 } from "node:path";
 function isInside(root, path) {
   const pathFromRoot = relative7(root, path);
   return pathFromRoot.length === 0 || !pathFromRoot.startsWith("..") && !isAbsolute7(pathFromRoot);
@@ -24166,14 +24840,14 @@ function candidates2(platform) {
   throw new Error(`Local MTA server startup is not supported on platform "${platform}". Use Windows or Linux.`);
 }
 function resolveServerExecutable(options) {
-  const serverRoot = resolve16(options.root, options.serverPath);
+  const serverRoot = resolve17(options.root, options.serverPath);
   const names = options.configured === null ? candidates2(options.platform ?? process.platform) : [options.configured];
   const attempted = [];
-  if (options.configured !== null && (isAbsolute7(options.configured) || !isInside(serverRoot, resolve16(serverRoot, options.configured)))) {
+  if (options.configured !== null && (isAbsolute7(options.configured) || !isInside(serverRoot, resolve17(serverRoot, options.configured)))) {
     throw new Error(`Configured development.server.executable must stay inside serverPath but received "${options.configured}".`);
   }
   for (const name of names) {
-    const path = resolve16(serverRoot, name);
+    const path = resolve17(serverRoot, name);
     attempted.push(path);
     try {
       if (!statSync5(path).isFile()) {
@@ -24533,8 +25207,520 @@ function registerEnsureCommand(program2, runtime) {
   });
 }
 
+// src/commands/format-command.ts
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { resolve as resolve19 } from "node:path";
+
+// src/format/format-selection.ts
+import { statSync as statSync6 } from "node:fs";
+import { relative as relative8, resolve as resolve18 } from "node:path";
+var UNREADABLE_PATH = "format-path-unreadable";
+function entryKind(absolute) {
+  try {
+    const stats = statSync6(absolute);
+    return stats.isDirectory() ? "directory" : "file";
+  } catch {
+    return null;
+  }
+}
+function sorted(files) {
+  return [...new Set(files)].sort((left, right) => left.localeCompare(right));
+}
+function selectProjectFiles(root, config) {
+  const resolver = createSourceResolver(config.sources);
+  const tree = listProjectFiles(root, ["."], [config.outDir]);
+  const files = tree.files.filter((path) => isSourcePath(path) && (isDeclarationPath(path) || resolver.resolve(path).matches.length > 0));
+  return { files: sorted(files), diagnostics: tree.errors.map((message) => cliError(UNREADABLE_PATH, message)) };
+}
+function selectPathFiles(root, paths) {
+  const files = [];
+  const diagnostics = [];
+  for (const entry of paths) {
+    const absolute = resolve18(root, entry);
+    const path = normalizePattern(relative8(root, absolute));
+    const kind = path.startsWith("..") ? null : entryKind(absolute);
+    if (kind === null) {
+      diagnostics.push(cliError(UNREADABLE_PATH, `"${normalizePattern(entry)}" does not exist in "${normalizePattern(root)}".`));
+      continue;
+    }
+    if (kind === "file") {
+      if (isSourcePath(path)) {
+        files.push(path);
+      } else {
+        diagnostics.push(cliError(UNREADABLE_PATH, `"${path}" is not a Luam source file.`));
+      }
+      continue;
+    }
+    const tree = listProjectFiles(root, [path]);
+    files.push(...tree.files.filter(isSourcePath));
+    diagnostics.push(...tree.errors.map((message) => cliError(UNREADABLE_PATH, message)));
+  }
+  return { files: sorted(files), diagnostics };
+}
+
+// src/format/formatter-file-system.ts
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import { dirname as dirname6, join as join6 } from "node:path";
+var NODE_FORMATTER_FILES = {
+  exists: (path) => existsSync13(path),
+  read: (path) => readFileSync11(path, "utf8"),
+  join: (directory, name) => join6(directory, name),
+  parent: (directory) => dirname6(directory)
+};
+
+// ../compiler/src/format/format-indent.ts
+var OPENERS = /* @__PURE__ */ new Set(["(", "[", "{", "then", "do", "repeat", "function"]);
+var CLOSERS = /* @__PURE__ */ new Set([")", "]", "}", "end", "until"]);
+function opensOf(piece) {
+  if (piece.kind === "comment") {
+    return 0;
+  }
+  return piece.value === "else" || OPENERS.has(piece.value) ? 1 : 0;
+}
+function closesOf(piece) {
+  if (piece.kind === "comment") {
+    return 0;
+  }
+  return piece.value === "else" || piece.value === "elseif" || CLOSERS.has(piece.value) ? 1 : 0;
+}
+function leadingRun(pieces) {
+  let length = 0;
+  while (length < pieces.length) {
+    const piece = pieces[length];
+    if (piece === void 0 || closesOf(piece) === 0) {
+      break;
+    }
+    length += 1;
+  }
+  return length;
+}
+function indentOf2(depth, pieces) {
+  const leading = leadingRun(pieces);
+  const indent = Math.max(0, leading === 0 ? depth : depth - 1);
+  const opened = pieces.reduce((total, piece, index) => total + opensOf(piece) - (index < leading ? 0 : closesOf(piece)), 0);
+  return { indent, next: opened > 0 ? indent + 1 : indent };
+}
+
+// ../compiler/src/format/format-options.ts
+var DEFAULT_FORMAT_OPTIONS = {
+  indent: "space",
+  indentWidth: 4,
+  keywordParenSpace: true,
+  maxBlankLines: 1,
+  lineEnding: "infer"
+};
+var MAX_INDENT_WIDTH = 8;
+var MAX_BLANK_LINES = 4;
+function resolveFormatOptions(options = {}) {
+  return { ...DEFAULT_FORMAT_OPTIONS, ...options };
+}
+function indentUnit(options) {
+  return options.indent === "tab" ? "	" : " ".repeat(options.indentWidth);
+}
+function newlineOf(source, options) {
+  if (options.lineEnding === "lf") {
+    return "\n";
+  }
+  if (options.lineEnding === "crlf") {
+    return "\r\n";
+  }
+  return source.includes("\r\n") ? "\r\n" : "\n";
+}
+
+// ../compiler/src/format/format-pieces.ts
+function isTypeOffset(erasures, offset) {
+  return erasures.some((span) => offset >= span.start && offset < span.end);
+}
+function tokenPiece(source, token, erasures) {
+  return {
+    kind: token.kind,
+    value: source.slice(token.position.offset, token.end.offset),
+    offset: token.position.offset,
+    line: token.position.line,
+    endLine: token.end.line,
+    isType: isTypeOffset(erasures, token.position.offset)
+  };
+}
+function commentPiece(source, comment) {
+  return {
+    kind: "comment",
+    value: source.slice(comment.position.offset, comment.end.offset).trimEnd(),
+    offset: comment.position.offset,
+    line: comment.position.line,
+    endLine: comment.end.line,
+    isType: false
+  };
+}
+function piecesOf(source, tokens, comments, erasures) {
+  const pieces = [
+    ...tokens.filter((token) => token.kind !== "eof").map((token) => tokenPiece(source, token, erasures)),
+    ...comments.map((comment) => commentPiece(source, comment))
+  ];
+  return pieces.sort((left, right) => left.offset - right.offset);
+}
+function linesOf(pieces) {
+  const lines = [];
+  let previous = null;
+  for (const piece of pieces) {
+    const current = lines[lines.length - 1];
+    if (previous !== null && current !== void 0 && piece.line === previous.endLine) {
+      current.pieces.push(piece);
+    } else {
+      lines.push({ pieces: [piece], blankLines: previous === null ? 0 : Math.max(0, piece.line - previous.endLine - 1) });
+    }
+    previous = piece;
+  }
+  return lines;
+}
+
+// ../compiler/src/format/format-spacing.ts
+var FUNCTION_TYPE2 = "fun";
+var VALUE_KINDS = /* @__PURE__ */ new Set(["identifier", "number", "string", "template"]);
+var VALUE_KEYWORDS = /* @__PURE__ */ new Set(["true", "false", "nil", "end"]);
+var TIGHT_BEFORE = /* @__PURE__ */ new Set([",", ";", ")", "]", ".", "?", ":", "++", "--"]);
+var TIGHT_AFTER = /* @__PURE__ */ new Set(["(", "[", ".", "@", "#", "..."]);
+var CALL_PREFIX = /* @__PURE__ */ new Set([")", "]"]);
+var TYPE_BRACKETS = /* @__PURE__ */ new Set(["<", ">"]);
+function endsValue(piece) {
+  if (piece.kind === "keyword") {
+    return VALUE_KEYWORDS.has(piece.value);
+  }
+  return VALUE_KINDS.has(piece.kind) || piece.value === ")" || piece.value === "]" || piece.value === "}";
+}
+function isName(piece) {
+  return piece.kind === "identifier" || piece.kind === "keyword" && isLuamKeyword(piece.value);
+}
+function bindsTight(piece) {
+  return isName(piece) || CALL_PREFIX.has(piece.value) || piece.isType && piece.value === ">";
+}
+function isUnary(pieces, index) {
+  const piece = pieces[index];
+  if (piece === void 0) {
+    return false;
+  }
+  if (piece.value === "#") {
+    return true;
+  }
+  if (piece.value !== "-") {
+    return false;
+  }
+  const previous = index === 0 ? void 0 : pieces[index - 1];
+  return previous === void 0 || !endsValue(previous);
+}
+function isMethodColon(pieces, index) {
+  const next = pieces[index + 1];
+  const after = pieces[index + 2];
+  if (next === void 0 || !isName(next) || next.value === FUNCTION_TYPE2) {
+    return false;
+  }
+  return after !== void 0 && after.value === "(";
+}
+function spaceBefore(pieces, index, options) {
+  const piece = pieces[index];
+  const previous = pieces[index - 1];
+  if (piece === void 0 || previous === void 0) {
+    return false;
+  }
+  if (piece.kind === "comment" || previous.kind === "comment") {
+    return true;
+  }
+  if (piece.value === "}") {
+    return previous.value !== "{";
+  }
+  if (piece.isType && piece.value === "<" && previous.kind === "keyword" && previous.value === "function") {
+    return true;
+  }
+  if (TIGHT_BEFORE.has(piece.value) || piece.isType && TYPE_BRACKETS.has(piece.value)) {
+    return false;
+  }
+  if (previous.isType && previous.value === "<") {
+    return false;
+  }
+  if (previous.value === ":") {
+    return !isMethodColon(pieces, index - 1);
+  }
+  if (TIGHT_AFTER.has(previous.value) || isUnary(pieces, index - 1)) {
+    return false;
+  }
+  if (piece.value === "(") {
+    return !bindsTight(previous) && (options.keywordParenSpace || previous.kind !== "keyword");
+  }
+  if (piece.value === "[") {
+    return !bindsTight(previous);
+  }
+  return true;
+}
+function renderLine(pieces, options) {
+  let text = "";
+  for (const [index, piece] of pieces.entries()) {
+    text += spaceBefore(pieces, index, options) ? ` ${piece.value}` : piece.value;
+  }
+  return text;
+}
+
+// ../compiler/src/format/format.ts
+function signature(pieces) {
+  return JSON.stringify(pieces.map((piece) => [piece.kind, piece.value]));
+}
+function render2(source, options) {
+  const parsed = parse(source);
+  if (parsed.diagnostics.length > 0) {
+    return null;
+  }
+  const pieces = piecesOf(source, parsed.tokens, parsed.comments, parsed.erasures);
+  const rendered = [];
+  const unit = indentUnit(options);
+  let depth = 0;
+  for (const line2 of linesOf(pieces)) {
+    const { indent, next } = indentOf2(depth, line2.pieces);
+    const first = line2.pieces[0];
+    const last = line2.pieces[line2.pieces.length - 1];
+    const blanks = rendered.length === 0 ? 0 : Math.min(line2.blankLines, options.maxBlankLines);
+    for (let count = 0; count < blanks; count += 1) {
+      rendered.push({ text: "", line: 0, endLine: 0 });
+    }
+    rendered.push({ text: `${unit.repeat(indent)}${renderLine(line2.pieces, options)}`, line: first?.line ?? 0, endLine: last?.endLine ?? 0 });
+    depth = next;
+  }
+  return { pieces, rendered, newline: newlineOf(source, options) };
+}
+function assemble(rendered, newline) {
+  return rendered.length === 0 ? "" : `${rendered.map((entry) => entry.text).join(newline)}${newline}`;
+}
+function verified(formatted, options) {
+  const text = assemble(formatted.rendered, formatted.newline);
+  const round = render2(text, options);
+  if (round === null || signature(round.pieces) !== signature(formatted.pieces)) {
+    return null;
+  }
+  return text;
+}
+function formatSource(source, options = {}) {
+  const resolved2 = resolveFormatOptions(options);
+  const formatted = render2(source, resolved2);
+  return formatted === null ? null : verified(formatted, resolved2);
+}
+
+// ../compiler/src/format/formatter-fields.ts
+var FORMATTER_FILE_NAME = ".luam.formatter";
+var INDENT_STYLES = ["space", "tab"];
+var LINE_ENDINGS = ["infer", "lf", "crlf"];
+var FORMATTER_FIELDS = [
+  field("indent", STRING_TYPE, 'The indent character. "space" indents with spaces, "tab" with tabs.', {
+    defaultValue: DEFAULT_FORMAT_OPTIONS.indent,
+    values: INDENT_STYLES
+  }),
+  field("indentWidth", NUMBER_TYPE, `Spaces per indent level, from 1 to ${MAX_INDENT_WIDTH}. Ignored when "indent" is "tab".`, {
+    defaultValue: DEFAULT_FORMAT_OPTIONS.indentWidth
+  }),
+  field("keywordParenSpace", BOOLEAN_TYPE, 'Whether a "(" that follows a keyword is preceded by a space, as in "function (".', {
+    defaultValue: DEFAULT_FORMAT_OPTIONS.keywordParenSpace
+  }),
+  field("maxBlankLines", NUMBER_TYPE, `Consecutive blank lines kept, from 0 to ${MAX_BLANK_LINES}.`, {
+    defaultValue: DEFAULT_FORMAT_OPTIONS.maxBlankLines
+  }),
+  field("lineEnding", STRING_TYPE, 'The line ending. "infer" follows the file, "lf" and "crlf" pin it.', {
+    defaultValue: DEFAULT_FORMAT_OPTIONS.lineEnding,
+    values: LINE_ENDINGS
+  })
+];
+var FORMATTER_FIELD_NAMES = FORMATTER_FIELDS.map((entry) => entry.name);
+
+// ../compiler/src/format/formatter-file.ts
+var FORMATTER_UNKNOWN_FIELD = "formatter-unknown-field";
+var FORMATTER_INVALID_VALUE = "formatter-invalid-value";
+var FORMATTER_PARSE_ERROR = "formatter-parse-error";
+var START4 = createPosition(1, 1, 0);
+function boundedInteger(value, name, low, high, positions, diagnostics) {
+  if (value === void 0) {
+    return null;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < low || value > high) {
+    diagnostics.push(manifestError(FORMATTER_INVALID_VALUE, `"${name}" must be a whole number from ${low} to ${high}.`, positionAt(positions, name)));
+    return null;
+  }
+  return value;
+}
+function choice(value, allowed) {
+  return typeof value === "string" && allowed.includes(value) ? value : null;
+}
+function retag(diagnostic) {
+  if (diagnostic.stage === "lexer" || diagnostic.stage === "parser") {
+    return { ...diagnostic, stage: "manifest", code: FORMATTER_PARSE_ERROR };
+  }
+  return { ...diagnostic, code: diagnostic.code === UNKNOWN_FIELD ? FORMATTER_UNKNOWN_FIELD : FORMATTER_INVALID_VALUE };
+}
+function unknownFieldMessage(name) {
+  const known = FORMATTER_FIELD_NAMES.map((entry) => `"${entry}"`).join(", ");
+  return `"${name}" is not a "${FORMATTER_FILE_NAME}" field. The fields are ${known}.`;
+}
+var FORMATTER_SCHEMA = {
+  fields: FORMATTER_FIELDS,
+  removed: {},
+  normalize: (value) => ({ value, diagnostics: [] }),
+  retag,
+  unknownName: unknownFieldMessage
+};
+function analyzeFormatterFile(source, root) {
+  const analysis = analyzeManifest(source, { mode: "format", root, env: {} }, FORMATTER_SCHEMA);
+  const diagnostics = [...analysis.diagnostics];
+  const raw = analysis.value;
+  const width = boundedInteger(raw["indentWidth"], "indentWidth", 1, MAX_INDENT_WIDTH, analysis.positions, diagnostics);
+  const blanks = boundedInteger(raw["maxBlankLines"], "maxBlankLines", 0, MAX_BLANK_LINES, analysis.positions, diagnostics);
+  const keywordParenSpace = raw["keywordParenSpace"];
+  return {
+    options: {
+      indent: choice(raw["indent"], INDENT_STYLES) ?? DEFAULT_FORMAT_OPTIONS.indent,
+      indentWidth: width ?? DEFAULT_FORMAT_OPTIONS.indentWidth,
+      keywordParenSpace: typeof keywordParenSpace === "boolean" ? keywordParenSpace : DEFAULT_FORMAT_OPTIONS.keywordParenSpace,
+      maxBlankLines: blanks ?? DEFAULT_FORMAT_OPTIONS.maxBlankLines,
+      lineEnding: choice(raw["lineEnding"], LINE_ENDINGS) ?? DEFAULT_FORMAT_OPTIONS.lineEnding
+    },
+    diagnostics
+  };
+}
+function formatterFileError(message) {
+  return manifestError(FORMATTER_PARSE_ERROR, message, START4);
+}
+
+// ../compiler/src/format/formatter-discovery.ts
+var LIBRARY_DIRECTORY2 = "node_modules";
+var DEFAULT_FORMATTER_OPTIONS = { path: null, options: DEFAULT_FORMAT_OPTIONS, diagnostics: [], valid: true };
+function insideLibrary(directory) {
+  return directory.split(/[\\/]/).includes(LIBRARY_DIRECTORY2);
+}
+function findFormatterFile(files, start) {
+  let directory = start;
+  for (; ; ) {
+    if (insideLibrary(directory)) {
+      return null;
+    }
+    const candidate = files.join(directory, FORMATTER_FILE_NAME);
+    if (files.exists(candidate)) {
+      return candidate;
+    }
+    const parent = files.parent(directory);
+    if (parent === directory) {
+      return null;
+    }
+    directory = parent;
+  }
+}
+function readFormatterFile(files, path, root) {
+  let source;
+  try {
+    source = files.read(path);
+  } catch (error) {
+    const message = `"${path}" could not be read: ${error instanceof Error ? error.message : String(error)}`;
+    return { path, options: DEFAULT_FORMAT_OPTIONS, diagnostics: [formatterFileError(message)], valid: false };
+  }
+  const analysis = analyzeFormatterFile(source, root);
+  return { path, options: analysis.options, diagnostics: analysis.diagnostics, valid: !hasErrors(analysis.diagnostics) };
+}
+function resolveFormatterOptions(files, start) {
+  const path = findFormatterFile(files, start);
+  return path === null ? DEFAULT_FORMATTER_OPTIONS : readFormatterFile(files, path, files.parent(path));
+}
+
+// src/commands/format-command.ts
+var UNPARSEABLE_SOURCE = "format-source-unparseable";
+var UNREADABLE_SOURCE2 = "format-source-unreadable";
+var UNWRITABLE_SOURCE = "format-source-unwritable";
+function describe2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function select(context, options) {
+  if (options.paths.length > 0) {
+    return selectPathFiles(context.root, options.paths);
+  }
+  if (context.config === null) {
+    return { files: [], diagnostics: [] };
+  }
+  return selectProjectFiles(context.root, context.config);
+}
+function formatFile(context, path, check2, style, diagnostics) {
+  const absolute = resolve19(context.root, path);
+  let source;
+  try {
+    source = readFileSync12(absolute, "utf8");
+  } catch (error) {
+    diagnostics.push(cliError(UNREADABLE_SOURCE2, `The source file "${path}" could not be read: ${describe2(error)}`));
+    return false;
+  }
+  const formatted = formatSource(source, style);
+  if (formatted === null) {
+    diagnostics.push(cliWarning(UNPARSEABLE_SOURCE, `"${path}" could not be parsed and was left unchanged. Run "luam check" to see why.`));
+    return false;
+  }
+  if (formatted === source) {
+    return false;
+  }
+  if (check2) {
+    return true;
+  }
+  try {
+    writeFileSync7(absolute, formatted, "utf8");
+  } catch (error) {
+    diagnostics.push(cliError(UNWRITABLE_SOURCE, `The source file "${path}" could not be written: ${describe2(error)}`));
+    return false;
+  }
+  return true;
+}
+function runFormatCommand(context, options) {
+  const reporter = context.reporter ?? createReporter(context.logger);
+  const started = Date.now();
+  const style = resolveFormatterOptions(NODE_FORMATTER_FILES, context.root);
+  if (!style.valid) {
+    reportManifestDiagnostics(reporter, style.path ?? "", "", style.diagnostics);
+    reporter.error(`The formatter configuration "${style.path ?? ""}" is invalid. Nothing was formatted.`);
+    return EXIT_USAGE;
+  }
+  const selection = select(context, options);
+  const diagnostics = [...selection.diagnostics];
+  const touched = [];
+  for (const path of selection.files) {
+    if (formatFile(context, path, options.check, style.options, diagnostics)) {
+      touched.push(path);
+    }
+  }
+  if (options.check) {
+    for (const path of touched) {
+      reporter.raw(path);
+    }
+  }
+  reportCliDiagnostics(reporter, diagnostics);
+  const failed3 = hasCliErrors(diagnostics) || options.check && touched.length > 0;
+  const label2 = options.check ? "differing" : "reformatted";
+  const summary = `${pluralize(selection.files.length, "file")} scanned, ${touched.length} ${label2} in ${formatDuration(Date.now() - started)}.`;
+  if (failed3) {
+    reporter.error(`Format failed: ${summary}`);
+    return EXIT_DIAGNOSTICS;
+  }
+  reporter.success(`Format passed: ${summary}`);
+  return EXIT_OK;
+}
+
+// src/cli/registry/format-registration.ts
+function registerFormatCommand(program2, runtime) {
+  const command = program2.command("format").description("Rewrite the project sources in the recorded formatting style.");
+  command.argument("[paths...]", "Files or directories to format instead of the manifest sources.");
+  addProjectOptions(command).addOption(new Option("--check", "Write nothing and report the files that differ."));
+  command.action((paths, options) => {
+    const check2 = options.check === true;
+    if (paths.length > 0) {
+      runtime.exitCode = runFormatCommand(
+        { root: commandRoot(runtime, options), config: null, logger: runtime.logger, reporter: runtime.reporter },
+        { check: check2, paths }
+      );
+      return;
+    }
+    const project = createProjectContext(runtime, "format", options);
+    runtime.exitCode = project.context === null ? project.error : runFormatCommand({ ...project.context, config: project.context.config }, { check: check2, paths: [] });
+  });
+}
+
 // src/cli/registry/init-registration.ts
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve21 } from "node:path";
 
 // src/commands/init-command.ts
 import { basename as basename2 } from "node:path";
@@ -24596,7 +25782,7 @@ function renderManifest(source, details) {
 }
 
 // src/scaffold/template-files.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync13 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../template/src/template.ts
@@ -24612,10 +25798,10 @@ function bundledTemplatePath(source) {
 }
 function resolveTemplatePath(source) {
   const packaged = fileURLToPath2(resolveTemplateUrl(source));
-  return existsSync11(packaged) ? packaged : bundledTemplatePath(source);
+  return existsSync14(packaged) ? packaged : bundledTemplatePath(source);
 }
 function readTemplateSource(source) {
-  return readFileSync10(resolveTemplatePath(source), "utf8");
+  return readFileSync13(resolveTemplatePath(source), "utf8");
 }
 
 // src/scaffold/scaffold-plan.ts
@@ -24631,19 +25817,19 @@ function buildScaffoldPlan(details) {
 }
 
 // src/scaffold/scaffold-writer.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname6, resolve as resolve17 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname7, resolve as resolve20 } from "node:path";
 function writeScaffold(targetDir, plan, force) {
   const written = [];
   const skipped = [];
   for (const file of plan.files) {
-    const absolute = resolve17(targetDir, file.path);
-    if (!force && existsSync12(absolute)) {
+    const absolute = resolve20(targetDir, file.path);
+    if (!force && existsSync15(absolute)) {
       skipped.push(file.path);
       continue;
     }
-    mkdirSync6(dirname6(absolute), { recursive: true });
-    writeFileSync7(absolute, file.content, "utf8");
+    mkdirSync6(dirname7(absolute), { recursive: true });
+    writeFileSync8(absolute, file.content, "utf8");
     written.push(file.path);
   }
   return { written: written.sort((left, right) => left.localeCompare(right)), skipped: skipped.sort((left, right) => left.localeCompare(right)) };
@@ -24693,7 +25879,7 @@ function registerInitCommand(program2, runtime) {
   command.addOption(cwdOption()).addOption(valueOption("--name <name>", "Resource name. Defaults to the destination directory name.")).addOption(new Option("--force", "Overwrite files that already exist.")).addOption(new Option("-y, --yes", "Accept the defaults without prompting.")).addOption(colorOption());
   command.action(async (path, options) => {
     const root = commandRoot(runtime, options);
-    const target = path === void 0 ? root : resolve18(root, path);
+    const target = path === void 0 ? root : resolve21(root, path);
     runtime.exitCode = await runInitCommand(target, runtime.logger, {
       name: options.name ?? null,
       force: options.force === true,
@@ -24817,13 +26003,13 @@ function registerServerCommand(program2, runtime) {
 }
 
 // src/testing/test-report.ts
-import { readFileSync as readFileSync11 } from "node:fs";
-import { resolve as resolve19 } from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
+import { resolve as resolve22 } from "node:path";
 function sourceLine(root, path, line2, cache3) {
   let lines = cache3.get(path);
   if (lines === void 0) {
     try {
-      lines = readFileSync11(resolve19(root, path), "utf8").split(/\r?\n/);
+      lines = readFileSync14(resolve22(root, path), "utf8").split(/\r?\n/);
     } catch {
       lines = [];
     }
@@ -24896,14 +26082,14 @@ function reportTestResults(reporter, runs, root, map, durationMs) {
 }
 
 // src/testing/test-discovery.ts
-import { readFileSync as readFileSync12 } from "node:fs";
-import { resolve as resolve20 } from "node:path";
+import { readFileSync as readFileSync15 } from "node:fs";
+import { resolve as resolve23 } from "node:path";
 var DEFAULT_TEST_ENVIRONMENT = "shared";
 var SIDE_CONFLICT2 = "test-source-side-conflict";
 var UNREADABLE_TEST = "test-source-unreadable";
 function readTest(root, path, diagnostics) {
   try {
-    return readFileSync12(resolve20(root, path), "utf8");
+    return readFileSync15(resolve23(root, path), "utf8");
   } catch (error) {
     diagnostics.push(cliError(UNREADABLE_TEST, `The test file "${path}" could not be read: ${error instanceof Error ? error.message : String(error)}`));
     return null;
@@ -24930,9 +26116,9 @@ function discoverTests(root, sources, excluded = []) {
 
 // src/testing/test-runner.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync8 } from "node:fs";
+import { mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync9 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname7, join as join6 } from "node:path";
+import { dirname as dirname8, join as join7 } from "node:path";
 
 // src/testing/harness-assertions.ts
 var ASSERTIONS_SOURCE = String.raw`local SENTINEL = '##luam:test'
@@ -25347,11 +26533,11 @@ function parseRunOutput(environment, stdout) {
   return { results, output };
 }
 function writeWorkspace(directory, scripts) {
-  writeFileSync8(join6(directory, HARNESS_FILE), HARNESS_SOURCE, "utf8");
+  writeFileSync9(join7(directory, HARNESS_FILE), HARNESS_SOURCE, "utf8");
   for (const script of scripts) {
-    const target = join6(directory, script.path);
-    mkdirSync7(dirname7(target), { recursive: true });
-    writeFileSync8(target, script.content, "utf8");
+    const target = join7(directory, script.path);
+    mkdirSync7(dirname8(target), { recursive: true });
+    writeFileSync9(target, script.content, "utf8");
   }
 }
 function loadOrder(available, environment) {
@@ -25365,14 +26551,14 @@ function loadOrder(available, environment) {
 }
 function runTests(request) {
   const spawn2 = request.spawn ?? runLua;
-  const directory = mkdtempSync2(join6(tmpdir2(), "luam-test-"));
+  const directory = mkdtempSync2(join7(tmpdir2(), "luam-test-"));
   const available = new Set(request.scripts.map((script) => script.path));
   try {
     writeWorkspace(directory, request.scripts);
     return ALL_ENVIRONMENTS.filter((environment) => request.environments.includes(environment)).map((environment) => {
       const { preload, target } = loadOrder(available, environment);
       const entry = entryFile(environment);
-      writeFileSync8(join6(directory, entry), entrySource(environment, preload, target), "utf8");
+      writeFileSync9(join7(directory, entry), entrySource(environment, preload, target), "utf8");
       const execution = spawn2(request.executable, [entry], directory);
       const parsed = parseRunOutput(environment, execution.stdout);
       const failure3 = execution.failure ?? (parsed.results.length === 0 && execution.stderr.length > 0 ? execution.stderr.trim() : null);
@@ -25444,12 +26630,12 @@ function registerTestCommand(program2, runtime) {
 }
 
 // src/commands/trace-command.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync16 } from "node:fs";
 function defaultMapPath(root, options, reporter) {
   const loaded = loadManifest(root, { path: options.manifestPath, mode: manifestMode("trace"), env: options.env });
   if (loaded.config !== null) {
     const configured = resourceMapPath(root, loaded.config);
-    if (existsSync13(configured)) {
+    if (existsSync16(configured)) {
       return configured;
     }
   }
@@ -25469,7 +26655,7 @@ function readStandardInput() {
     return "";
   }
   try {
-    return readFileSync13(0, "utf8");
+    return readFileSync16(0, "utf8");
   } catch {
     return "";
   }
@@ -25551,6 +26737,7 @@ var COMMAND_REGISTRARS = [
   registerDevCommand,
   registerDoctorCommand,
   registerEnsureCommand,
+  registerFormatCommand,
   registerInitCommand,
   registerServerCommand,
   registerSetupCommand,