@thigasdevelopment/luam 0.19.5 → 0.19.8

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);
   }
@@ -4008,6 +4019,188 @@ function parseNamedAnnotation(stream, declaration) {
   return { kind: "type-optional", element, position: optional.position };
 }
 
+// ../compiler/src/parser/token-stream.ts
+var ParserError = class extends Error {
+  diagnostic;
+  constructor(diagnostic) {
+    super(diagnostic.message);
+    this.name = "ParserError";
+    this.diagnostic = diagnostic;
+  }
+};
+var TokenStream = class {
+  diagnostics = [];
+  tokens;
+  index = 0;
+  erased = [];
+  spans = /* @__PURE__ */ new Map();
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  peek(offset = 0) {
+    const token = this.tokens[Math.min(this.index + offset, this.tokens.length - 1)];
+    return token;
+  }
+  current() {
+    return this.peek();
+  }
+  isEof() {
+    return this.current().kind === "eof";
+  }
+  next() {
+    const token = this.current();
+    if (!this.isEof()) {
+      this.index += 1;
+    }
+    return token;
+  }
+  checkpoint() {
+    return this.index;
+  }
+  speculate() {
+    return { index: this.index, erasures: this.erased.length, diagnostics: this.diagnostics.length };
+  }
+  rewind(point) {
+    this.index = point.index;
+    this.erased.length = point.erasures;
+    this.diagnostics.length = point.diagnostics;
+  }
+  eraseFrom(checkpoint, kind = "annotation") {
+    const first = this.tokens[checkpoint];
+    const last = this.tokens[this.index - 1];
+    if (first !== void 0 && last !== void 0 && first.kind !== "eof") {
+      this.erased.push({ start: first.position.offset, end: last.end.offset, kind });
+    }
+  }
+  eraseToCurrent(checkpoint) {
+    const first = this.tokens[checkpoint];
+    if (first !== void 0 && first.kind !== "eof") {
+      this.erased.push({ start: first.position.offset, end: this.current().position.offset, kind: "annotation" });
+    }
+  }
+  extendDeclarationErasure(end) {
+    const last = this.erased[this.erased.length - 1];
+    if (last !== void 0 && last.kind === "declaration" && last.end <= end) {
+      last.end = end;
+    }
+  }
+  erasures() {
+    return [...this.erased];
+  }
+  recordSpan(node, checkpoint) {
+    const span = this.sourceSpanFrom(checkpoint);
+    if (span !== null) {
+      this.spans.set(node, span);
+    }
+  }
+  nodeSpans() {
+    return this.spans;
+  }
+  sourceSpanFrom(checkpoint) {
+    const first = this.tokens[checkpoint];
+    const last = this.tokens[this.index - 1];
+    return first === void 0 || last === void 0 || first.kind === "eof" ? null : { start: first.position.offset, end: last.end.offset };
+  }
+  check(kind, value) {
+    const token = this.current();
+    return token.kind === kind && (value === void 0 || token.value === value);
+  }
+  checkAhead(offset, kind, value) {
+    const token = this.peek(offset);
+    return token.kind === kind && (value === void 0 || token.value === value);
+  }
+  match(kind, value) {
+    if (!this.check(kind, value)) {
+      return false;
+    }
+    this.next();
+    return true;
+  }
+  expect(kind, value) {
+    if (this.check(kind, value)) {
+      return this.next();
+    }
+    const expected = value === void 0 ? kind : `"${value}"`;
+    throw this.error(`Expected ${expected} but found "${this.describeCurrent()}".`, "parse-unexpected-token");
+  }
+  checkName(offset = 0) {
+    const token = this.peek(offset);
+    return token.kind === "identifier" || token.kind === "keyword" && isLuamKeyword(token.value);
+  }
+  expectName() {
+    if (this.checkName()) {
+      return this.next();
+    }
+    throw this.error(`Expected a name but found "${this.describeCurrent()}".`, "parse-unexpected-token");
+  }
+  describeCurrent() {
+    const token = this.current();
+    return token.kind === "eof" ? "<end of file>" : token.value;
+  }
+  error(message, code = "parse-error") {
+    const token = this.current();
+    return new ParserError(createDiagnostic("parser", code, message, token.position, "error", token.end));
+  }
+  errorAt(message, code, position2, end) {
+    return new ParserError(createDiagnostic("parser", code, message, position2, "error", end));
+  }
+  report(code, message, position2) {
+    this.diagnostics.push(createDiagnostic("parser", code, message, position2));
+  }
+};
+
+// ../compiler/src/parser/type-parameters.ts
+function emptyTypeParameters() {
+  return { names: [], constraints: [] };
+}
+function parseTypeParameters(stream) {
+  const list = emptyTypeParameters();
+  if (!stream.check("operator", "<")) {
+    return list;
+  }
+  const checkpoint = stream.checkpoint();
+  stream.next();
+  do {
+    list.names.push(stream.expect("identifier").value);
+    list.constraints.push(stream.match("keyword", "extends") ? parseTypeAnnotation(stream) : null);
+  } while (stream.match("punctuation", ","));
+  stream.expect("operator", ">");
+  stream.eraseFrom(checkpoint);
+  return list;
+}
+function parseTypeArguments(stream) {
+  const args = [];
+  if (!stream.check("operator", "<")) {
+    return args;
+  }
+  const checkpoint = stream.checkpoint();
+  stream.next();
+  do {
+    args.push(parseTypeAnnotation(stream));
+  } while (stream.match("punctuation", ","));
+  stream.expect("operator", ">");
+  stream.eraseFrom(checkpoint);
+  return args;
+}
+function parseCallTypeArguments(stream) {
+  if (!stream.check("operator", "<")) {
+    return [];
+  }
+  const point = stream.speculate();
+  try {
+    const args = parseTypeArguments(stream);
+    if (args.length > 0 && stream.check("punctuation", "(")) {
+      return args;
+    }
+  } catch (error) {
+    if (!(error instanceof ParserError)) {
+      throw error;
+    }
+  }
+  stream.rewind(point);
+  return [];
+}
+
 // ../compiler/src/parser/function-expression.ts
 function parseParameter(stream) {
   const token = stream.current();
@@ -4038,11 +4231,20 @@ function parseParameters(stream) {
 }
 function parseFunctionExpression(stream) {
   const position2 = stream.expect("keyword", "function").position;
+  const typeParameters = parseTypeParameters(stream);
   const parameters = parseParameters(stream);
   const returnAnnotation = parseOptionalAnnotation(stream);
   const body = parseBlock(stream, ["end"]);
   stream.expect("keyword", "end");
-  return { kind: "function-expression", parameters, returnAnnotation, body, position: position2 };
+  return {
+    kind: "function-expression",
+    typeParameters: typeParameters.names,
+    typeConstraints: typeParameters.constraints,
+    parameters,
+    returnAnnotation,
+    body,
+    position: position2
+  };
 }
 function parseFunctionName(stream) {
   const token = stream.expect("identifier");
@@ -4060,11 +4262,25 @@ function parseFunctionName(stream) {
 function parseFunctionDeclaration(stream, isLocal, isExported = false, isHttpExport = false) {
   const position2 = stream.expect("keyword", "function").position;
   const { name, isMethod } = parseFunctionName(stream);
+  const typeParameters = parseTypeParameters(stream);
   const parameters = parseParameters(stream);
   const returnAnnotation = parseOptionalAnnotation(stream);
   const body = parseBlock(stream, ["end"]);
   stream.expect("keyword", "end");
-  return { kind: "function-declaration", name, isLocal, isExported, isHttpExport, isMethod, parameters, returnAnnotation, body, position: position2 };
+  return {
+    kind: "function-declaration",
+    name,
+    isLocal,
+    isExported,
+    isHttpExport,
+    isMethod,
+    typeParameters: typeParameters.names,
+    typeConstraints: typeParameters.constraints,
+    parameters,
+    returnAnnotation,
+    body,
+    position: position2
+  };
 }
 
 // ../compiler/src/parser/precedence.ts
@@ -4159,7 +4375,7 @@ function parsePrimary(stream) {
   if (token.kind === "keyword" && token.value === "new" && stream.checkAhead(1, "identifier")) {
     stream.next();
     const className = stream.next().value;
-    const typeArguments = parseNewTypeArguments(stream);
+    const typeArguments = parseTypeArguments(stream);
     return { kind: "new-expression", className, typeArguments, args: parseArguments(stream), position: token.position };
   }
   if (token.kind === "keyword" && CALLABLE_KEYWORDS.has(token.value) && stream.checkAhead(1, "punctuation", "(")) {
@@ -4192,20 +4408,6 @@ function parsePrimary(stream) {
   }
   throw stream.error(`Unexpected "${stream.describeCurrent()}" in expression.`, "parse-unexpected-token");
 }
-function parseNewTypeArguments(stream) {
-  const args = [];
-  if (!stream.check("operator", "<")) {
-    return args;
-  }
-  const checkpoint = stream.checkpoint();
-  stream.next();
-  do {
-    args.push(parseTypeAnnotation(stream));
-  } while (stream.match("punctuation", ","));
-  stream.expect("operator", ">");
-  stream.eraseFrom(checkpoint);
-  return args;
-}
 function parseArguments(stream) {
   if (stream.check("string") || stream.check("template") || stream.check("punctuation", "{")) {
     return [parsePrimary(stream)];
@@ -4244,11 +4446,13 @@ function parseSuffixed(stream) {
     if (token.kind === "punctuation" && token.value === ":" && stream.checkName(1)) {
       stream.next();
       const method = stream.next().value;
-      expression = { kind: "call-expression", callee: expression, method, args: parseArguments(stream), position: token.position };
+      const typeArguments2 = parseCallTypeArguments(stream);
+      expression = { kind: "call-expression", callee: expression, method, typeArguments: typeArguments2, args: parseArguments(stream), position: token.position };
       continue;
     }
-    if (isCallStart(stream)) {
-      expression = { kind: "call-expression", callee: expression, method: null, args: parseArguments(stream), position: token.position };
+    const typeArguments = parseCallTypeArguments(stream);
+    if (typeArguments.length > 0 || isCallStart(stream)) {
+      expression = { kind: "call-expression", callee: expression, method: null, typeArguments, args: parseArguments(stream), position: token.position };
       continue;
     }
     return expression;
@@ -4256,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();
@@ -4367,166 +4571,44 @@ function recoverInBlock(stream, error, terminators = BRACE_TERMINATORS) {
   }
 }
 
-// ../compiler/src/parser/token-stream.ts
-var ParserError = class extends Error {
-  diagnostic;
-  constructor(diagnostic) {
-    super(diagnostic.message);
-    this.name = "ParserError";
-    this.diagnostic = diagnostic;
+// ../compiler/src/parser/declarations.ts
+var DECLARATION_NAMES = /* @__PURE__ */ new Set(["class", "interface", "enum"]);
+var CLASS_MODIFIERS = /* @__PURE__ */ new Set(["extends", "implements"]);
+function skipTypeParameters(stream, offset) {
+  if (!stream.checkAhead(offset, "operator", "<")) {
+    return offset;
   }
-};
-var TokenStream = class {
-  diagnostics = [];
-  tokens;
-  index = 0;
-  erased = [];
-  spans = /* @__PURE__ */ new Map();
-  constructor(tokens) {
-    this.tokens = tokens;
+  let depth = 0;
+  let index = offset;
+  do {
+    const token = stream.peek(index);
+    depth += token.kind === "operator" && token.value === "<" ? 1 : 0;
+    depth -= token.kind === "operator" && token.value === ">" ? 1 : 0;
+    index += 1;
+  } while (depth > 0 && stream.peek(index).kind !== "eof");
+  return index;
+}
+function isClassHeader(stream, offset = 0) {
+  const after = skipTypeParameters(stream, offset + 2);
+  return stream.checkAhead(after, "punctuation", "{") || stream.checkAhead(after, "keyword", "extends") || stream.checkAhead(after, "keyword", "implements");
+}
+function isDeclarationStart(stream) {
+  let offset = 0;
+  while (stream.checkAhead(offset, "punctuation", "@") && stream.checkAhead(offset + 1, "identifier")) {
+    offset += 2;
+    if (stream.checkAhead(offset, "punctuation", "(")) {
+      let depth = 0;
+      do {
+        const token2 = stream.peek(offset);
+        depth += token2.kind === "punctuation" && token2.value === "(" ? 1 : 0;
+        depth -= token2.kind === "punctuation" && token2.value === ")" ? 1 : 0;
+        offset += 1;
+      } while (depth > 0 && stream.peek(offset).kind !== "eof");
+    }
   }
-  peek(offset = 0) {
-    const token = this.tokens[Math.min(this.index + offset, this.tokens.length - 1)];
-    return token;
-  }
-  current() {
-    return this.peek();
-  }
-  isEof() {
-    return this.current().kind === "eof";
-  }
-  next() {
-    const token = this.current();
-    if (!this.isEof()) {
-      this.index += 1;
-    }
-    return token;
-  }
-  checkpoint() {
-    return this.index;
-  }
-  eraseFrom(checkpoint, kind = "annotation") {
-    const first = this.tokens[checkpoint];
-    const last = this.tokens[this.index - 1];
-    if (first !== void 0 && last !== void 0 && first.kind !== "eof") {
-      this.erased.push({ start: first.position.offset, end: last.end.offset, kind });
-    }
-  }
-  eraseToCurrent(checkpoint) {
-    const first = this.tokens[checkpoint];
-    if (first !== void 0 && first.kind !== "eof") {
-      this.erased.push({ start: first.position.offset, end: this.current().position.offset, kind: "annotation" });
-    }
-  }
-  extendDeclarationErasure(end) {
-    const last = this.erased[this.erased.length - 1];
-    if (last !== void 0 && last.kind === "declaration" && last.end <= end) {
-      last.end = end;
-    }
-  }
-  erasures() {
-    return [...this.erased];
-  }
-  recordSpan(node, checkpoint) {
-    const span = this.sourceSpanFrom(checkpoint);
-    if (span !== null) {
-      this.spans.set(node, span);
-    }
-  }
-  nodeSpans() {
-    return this.spans;
-  }
-  sourceSpanFrom(checkpoint) {
-    const first = this.tokens[checkpoint];
-    const last = this.tokens[this.index - 1];
-    return first === void 0 || last === void 0 || first.kind === "eof" ? null : { start: first.position.offset, end: last.end.offset };
-  }
-  check(kind, value) {
-    const token = this.current();
-    return token.kind === kind && (value === void 0 || token.value === value);
-  }
-  checkAhead(offset, kind, value) {
-    const token = this.peek(offset);
-    return token.kind === kind && (value === void 0 || token.value === value);
-  }
-  match(kind, value) {
-    if (!this.check(kind, value)) {
-      return false;
-    }
-    this.next();
-    return true;
-  }
-  expect(kind, value) {
-    if (this.check(kind, value)) {
-      return this.next();
-    }
-    const expected = value === void 0 ? kind : `"${value}"`;
-    throw this.error(`Expected ${expected} but found "${this.describeCurrent()}".`, "parse-unexpected-token");
-  }
-  checkName(offset = 0) {
-    const token = this.peek(offset);
-    return token.kind === "identifier" || token.kind === "keyword" && isLuamKeyword(token.value);
-  }
-  expectName() {
-    if (this.checkName()) {
-      return this.next();
-    }
-    throw this.error(`Expected a name but found "${this.describeCurrent()}".`, "parse-unexpected-token");
-  }
-  describeCurrent() {
-    const token = this.current();
-    return token.kind === "eof" ? "<end of file>" : token.value;
-  }
-  error(message, code = "parse-error") {
-    const token = this.current();
-    return new ParserError(createDiagnostic("parser", code, message, token.position, "error", token.end));
-  }
-  errorAt(message, code, position2, end) {
-    return new ParserError(createDiagnostic("parser", code, message, position2, "error", end));
-  }
-  report(code, message, position2) {
-    this.diagnostics.push(createDiagnostic("parser", code, message, position2));
-  }
-};
-
-// ../compiler/src/parser/declarations.ts
-var DECLARATION_NAMES = /* @__PURE__ */ new Set(["class", "interface", "enum"]);
-var CLASS_MODIFIERS = /* @__PURE__ */ new Set(["extends", "implements"]);
-function skipTypeParameters(stream, offset) {
-  if (!stream.checkAhead(offset, "operator", "<")) {
-    return offset;
-  }
-  let depth = 0;
-  let index = offset;
-  do {
-    const token = stream.peek(index);
-    depth += token.kind === "operator" && token.value === "<" ? 1 : 0;
-    depth -= token.kind === "operator" && token.value === ">" ? 1 : 0;
-    index += 1;
-  } while (depth > 0 && stream.peek(index).kind !== "eof");
-  return index;
-}
-function isClassHeader(stream, offset = 0) {
-  const after = skipTypeParameters(stream, offset + 2);
-  return stream.checkAhead(after, "punctuation", "{") || stream.checkAhead(after, "keyword", "extends") || stream.checkAhead(after, "keyword", "implements");
-}
-function isDeclarationStart(stream) {
-  let offset = 0;
-  while (stream.checkAhead(offset, "punctuation", "@") && stream.checkAhead(offset + 1, "identifier")) {
-    offset += 2;
-    if (stream.checkAhead(offset, "punctuation", "(")) {
-      let depth = 0;
-      do {
-        const token2 = stream.peek(offset);
-        depth += token2.kind === "punctuation" && token2.value === "(" ? 1 : 0;
-        depth -= token2.kind === "punctuation" && token2.value === ")" ? 1 : 0;
-        offset += 1;
-      } while (depth > 0 && stream.peek(offset).kind !== "eof");
-    }
-  }
-  const token = stream.peek(offset);
-  if (token.kind !== "keyword" || !DECLARATION_NAMES.has(token.value) || !stream.checkAhead(offset + 1, "identifier")) {
-    return false;
+  const token = stream.peek(offset);
+  if (token.kind !== "keyword" || !DECLARATION_NAMES.has(token.value) || !stream.checkAhead(offset + 1, "identifier")) {
+    return false;
   }
   if (offset > 0 && token.value !== "class") {
     return false;
@@ -4573,6 +4655,8 @@ function parseClassMethod(stream, token, decorators, isStatic) {
     isConstructor: token.value === "constructor",
     isSynthetic: false,
     isStatic,
+    typeParameters: expression.typeParameters,
+    typeConstraints: expression.typeConstraints,
     parameters: expression.parameters,
     returnAnnotation: expression.returnAnnotation,
     body: expression.body,
@@ -4590,6 +4674,8 @@ function parseBraceClassMethod(stream, token, decorators, isStatic) {
     isConstructor: token.value === "constructor",
     isSynthetic: false,
     isStatic,
+    typeParameters: [],
+    typeConstraints: [],
     parameters,
     returnAnnotation,
     body,
@@ -4638,35 +4724,6 @@ function parseClassMember(stream) {
   expectClassFieldBoundary(stream, token);
   return { kind: "class-field", name: token.value, annotation, value, decorators, isStatic, position: token.position };
 }
-function parseTypeParameters(stream) {
-  const list = { names: [], constraints: [] };
-  if (!stream.check("operator", "<")) {
-    return list;
-  }
-  const checkpoint = stream.checkpoint();
-  stream.next();
-  do {
-    list.names.push(stream.expect("identifier").value);
-    list.constraints.push(stream.match("keyword", "extends") ? parseTypeAnnotation(stream) : null);
-  } while (stream.match("punctuation", ","));
-  stream.expect("operator", ">");
-  stream.eraseFrom(checkpoint);
-  return list;
-}
-function parseTypeArguments(stream) {
-  const args = [];
-  if (!stream.check("operator", "<")) {
-    return args;
-  }
-  const checkpoint = stream.checkpoint();
-  stream.next();
-  do {
-    args.push(parseTypeAnnotation(stream));
-  } while (stream.match("punctuation", ","));
-  stream.expect("operator", ">");
-  stream.eraseFrom(checkpoint);
-  return args;
-}
 function parseClassModifiers(stream, declaration) {
   while (stream.check("keyword") && CLASS_MODIFIERS.has(stream.current().value)) {
     if (stream.next().value === "extends") {
@@ -5129,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.';
@@ -5305,10 +5364,12 @@ function typeToString(type) {
   }
   if (type.kind === "function") {
     const parameters = type.parameters.map(typeToString);
+    const names = type.typeParameters ?? [];
     if (type.isVariadic) {
       parameters.push(type.variadicType === void 0 ? "..." : `...: ${typeToString(type.variadicType)}`);
     }
-    return `fun(${parameters.join(", ")}): ${typeToString(type.returnType)}`;
+    const generic = names.length === 0 ? "" : `<${names.join(", ")}>`;
+    return `fun${generic}(${parameters.join(", ")}): ${typeToString(type.returnType)}`;
   }
   return type.kind;
 }
@@ -5754,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",
@@ -5918,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) {
@@ -5958,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 };
   }
@@ -5985,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 };
   }
@@ -6337,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._-]*$/;
@@ -6429,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)) {
@@ -6465,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}`;
@@ -6494,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) {
@@ -6505,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);
     }
@@ -6518,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 = [];
@@ -6545,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,
@@ -6625,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 };
@@ -6684,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"),
@@ -6697,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),
@@ -6709,6 +6918,7 @@ function validateConfig(value, positions) {
     development: readDevelopment(readTable(value, "development"))
   };
   checkDependencies(name, dependencies, context);
+  checkLibraries(libraries, context);
   return { config, diagnostics: context.diagnostics };
 }
 
@@ -6762,7 +6972,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.19.5" : "0.0.0-dev";
+var VERSION = true ? "0.19.8" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -7296,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.");
 }
@@ -7411,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 };
@@ -7476,78 +7689,9 @@ function readHelperSource(helper, file) {
   return readFileSync4(resolveHelperPath(helper, file), "utf8");
 }
 
-// src/build/build-phase.ts
-var COUNTED_PHASES = /* @__PURE__ */ new Set(["compile", "write"]);
-var PHASE_LABELS = {
-  version: "Version",
-  discovery: "Discovery",
-  compile: "Compile",
-  assembly: "Assembly",
-  manifest: "Manifest",
-  write: "Write",
-  sync: "Sync",
-  restart: "Restart"
-};
-var PHASE_UNITS = {
-  version: "step",
-  discovery: "file",
-  compile: "file",
-  assembly: "step",
-  manifest: "step",
-  write: "file",
-  sync: "file",
-  restart: "step"
-};
-function isCountedPhase(phase) {
-  return COUNTED_PHASES.has(phase);
-}
-
-// src/build/phase-tracker.ts
-function createPhaseTracker(listener = null) {
-  const closed = [];
-  let open = null;
-  function emit3(phase, state, item, durationMs) {
-    listener?.({ phase: phase.phase, state, completed: phase.completed, total: phase.total, item, durationMs });
-  }
-  function close(state) {
-    if (open === null) {
-      return;
-    }
-    const durationMs = performance.now() - open.startedAt;
-    const completed = state === "done" && isCountedPhase(open.phase) ? open.total : open.completed;
-    const finished = { ...open, completed };
-    closed.push({ phase: open.phase, state, completed, total: open.total, durationMs });
-    open = null;
-    emit3(finished, state, null, durationMs);
-  }
-  return {
-    begin: (phase, total = 0) => {
-      close("done");
-      open = { phase, startedAt: performance.now(), completed: 0, total };
-      emit3(open, "active", null, 0);
-    },
-    advance: (item, completed, total) => {
-      if (open === null) {
-        return;
-      }
-      open.completed = completed;
-      open.total = total;
-      emit3(open, "active", item, performance.now() - open.startedAt);
-    },
-    end: (state = "done") => {
-      close(state);
-    },
-    durations: () => [...closed]
-  };
-}
-
-// src/build/project-inputs.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
-
-// src/build/asset-resolution.ts
-import { statSync as statSync3 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
+// 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";
@@ -7597,6 +7741,196 @@ function listProjectFiles(root, roots, excluded = []) {
   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 = {
+  version: "Version",
+  discovery: "Discovery",
+  compile: "Compile",
+  assembly: "Assembly",
+  manifest: "Manifest",
+  write: "Write",
+  sync: "Sync",
+  restart: "Restart"
+};
+var PHASE_UNITS = {
+  version: "step",
+  discovery: "file",
+  compile: "file",
+  assembly: "step",
+  manifest: "step",
+  write: "file",
+  sync: "file",
+  restart: "step"
+};
+function isCountedPhase(phase) {
+  return COUNTED_PHASES.has(phase);
+}
+
+// src/build/phase-tracker.ts
+function createPhaseTracker(listener = null) {
+  const closed = [];
+  let open = null;
+  function emit3(phase, state, item, durationMs) {
+    listener?.({ phase: phase.phase, state, completed: phase.completed, total: phase.total, item, durationMs });
+  }
+  function close(state) {
+    if (open === null) {
+      return;
+    }
+    const durationMs = performance.now() - open.startedAt;
+    const completed = state === "done" && isCountedPhase(open.phase) ? open.total : open.completed;
+    const finished = { ...open, completed };
+    closed.push({ phase: open.phase, state, completed, total: open.total, durationMs });
+    open = null;
+    emit3(finished, state, null, durationMs);
+  }
+  return {
+    begin: (phase, total = 0) => {
+      close("done");
+      open = { phase, startedAt: performance.now(), completed: 0, total };
+      emit3(open, "active", null, 0);
+    },
+    advance: (item, completed, total) => {
+      if (open === null) {
+        return;
+      }
+      open.completed = completed;
+      open.total = total;
+      emit3(open, "active", item, performance.now() - open.startedAt);
+    },
+    end: (state = "done") => {
+      close(state);
+    },
+    durations: () => [...closed]
+  };
+}
+
+// src/build/project-inputs.ts
+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 resolve7 } from "node:path";
+
 // ../compiler/src/project/resource-map.ts
 var RESOURCE_MAP_VERSION = 1;
 function findSegment(segments, line2) {
@@ -7669,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 }));
@@ -7731,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;
@@ -7753,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"
 };
@@ -7819,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)));
@@ -7903,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) {
@@ -7924,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) {
@@ -8085,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);
@@ -8160,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
@@ -8195,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;
@@ -8270,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.`));
@@ -8287,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;
   }
@@ -8306,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) {
@@ -8327,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";
@@ -8371,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;
@@ -8780,6 +9134,13 @@ function assignmentFact(narrowed, declared) {
 }
 
 // ../compiler/src/checker/type-substitution.ts
+function shadowed(substitutions, names) {
+  const remaining = new Map(substitutions);
+  for (const name of names) {
+    remaining.delete(name);
+  }
+  return remaining;
+}
 function substituteType(type, substitutions) {
   if (type.kind === "named") {
     const args = type.typeArguments ?? [];
@@ -8801,10 +9162,17 @@ function substituteType(type, substitutions) {
     return createUnion(type.options.map((option) => substituteType(option, substitutions)));
   }
   if (type.kind === "function") {
-    const parameters = type.parameters.map((parameter) => substituteType(parameter, substitutions));
-    const returnType = substituteType(type.returnType, substitutions);
-    const variadicType = type.variadicType === void 0 ? void 0 : substituteType(type.variadicType, substitutions);
-    return createFunction(parameters, returnType, type.minimumArguments, type.isVariadic, type.parameterNames, variadicType);
+    const own = type.typeParameters ?? [];
+    const outer = own.length === 0 ? substitutions : shadowed(substitutions, own);
+    const parameters = type.parameters.map((parameter) => substituteType(parameter, outer));
+    const returnType = substituteType(type.returnType, outer);
+    const variadicType = type.variadicType === void 0 ? void 0 : substituteType(type.variadicType, outer);
+    const substituted = createFunction(parameters, returnType, type.minimumArguments, type.isVariadic, type.parameterNames, variadicType);
+    if (own.length > 0) {
+      substituted.typeParameters = [...own];
+      substituted.typeConstraints = (type.typeConstraints ?? []).map((constraint) => constraint === null ? null : substituteType(constraint, outer));
+    }
+    return substituted;
   }
   if (type.kind === "tuple") {
     return createTuple(type.elements.map((element) => substituteType(element, substitutions)));
@@ -8921,21 +9289,24 @@ function satisfies(context, argument, constraint) {
   }
   return isAssignable(argument, constraint, { allowNil: false });
 }
-function checkTypeConstraints(context, name, typeArguments, position2) {
-  const info = context.declarations.lookupClass(name);
-  if (info === null) {
-    return;
-  }
-  info.typeConstraints.forEach((constraint, index) => {
+function reportConstraintViolations(context, owner, typeParameters, typeConstraints, typeArguments, position2) {
+  typeConstraints.forEach((constraint, index) => {
     const argument = typeArguments[index];
     if (constraint === null || argument === void 0 || argument.kind === "any" || satisfies(context, argument, constraint)) {
       return;
     }
-    const parameter = info.typeParameters[index] ?? "T";
-    const message = `Type argument "${typeToString(argument)}" does not satisfy "${parameter} extends ${typeToString(constraint)}" on class "${name}".`;
+    const parameter = typeParameters[index] ?? "T";
+    const message = `Type argument "${typeToString(argument)}" does not satisfy "${parameter} extends ${typeToString(constraint)}" on ${owner}.`;
     context.report("check-generic-constraint", message, position2);
   });
 }
+function checkTypeConstraints(context, name, typeArguments, position2) {
+  const info = context.declarations.lookupClass(name);
+  if (info === null) {
+    return;
+  }
+  reportConstraintViolations(context, `class "${name}"`, info.typeParameters, info.typeConstraints, typeArguments, position2);
+}
 
 // ../mta-types/src/lua-standard.ts
 var LUA_GLOBALS = {
@@ -14925,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) {
@@ -15027,6 +15398,8 @@ function accessorMethod(field2, decorator, name) {
     isConstructor: false,
     isSynthetic: true,
     isStatic: false,
+    typeParameters: [],
+    typeConstraints: [],
     parameters: decorator === "Getter" ? [] : [value],
     returnAnnotation: decorator === "Getter" ? field2.annotation : voidAnnotation,
     body,
@@ -15035,7 +15408,7 @@ function accessorMethod(field2, decorator, name) {
   };
 }
 function generatedMethod(field2, name, parameters, returnAnnotation, kind, fields) {
-  return { kind: "class-method", name, isConstructor: false, isSynthetic: true, isStatic: false, parameters, returnAnnotation, body: [], decorators: [], generated: { kind, fields }, position: field2.position };
+  return { kind: "class-method", name, isConstructor: false, isSynthetic: true, isStatic: false, typeParameters: [], typeConstraints: [], parameters, returnAnnotation, body: [], decorators: [], generated: { kind, fields }, position: field2.position };
 }
 function typeName(name, node) {
   return { kind: "type-name", name, typeArguments: [], position: node.position };
@@ -15073,6 +15446,8 @@ function staticMethod(statement, name, returnAnnotation, kind, descriptor) {
     isConstructor: false,
     isSynthetic: true,
     isStatic: true,
+    typeParameters: [],
+    typeConstraints: [],
     parameters: [value],
     returnAnnotation,
     body: [],
@@ -18541,33 +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(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, 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 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, 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
@@ -18579,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
@@ -18883,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;
@@ -18943,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);
@@ -18968,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);
@@ -19031,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));
@@ -19383,15 +19841,48 @@ function checkLoopBody(context, body, facts) {
   checkBlock(context, body);
   context.setFlow(entry);
 }
-function checkWhile(context, statement) {
-  forgetAssignedPaths(context, statement.body);
-  checkExpression(context, statement.condition);
-  checkLoopBody(context, statement.body, conditionFacts(context, statement.condition));
-  context.applyFlowFacts(negatedFacts(context, statement.condition));
+function isTruthyLiteral(condition) {
+  if (condition.kind === "group-expression") {
+    return isTruthyLiteral(condition.expression);
+  }
+  const literal2 = condition.kind === "number-literal" || condition.kind === "string-literal" || condition.kind === "template-literal";
+  return literal2 || condition.kind === "boolean-literal" && condition.value;
 }
-function checkRepeat(context, statement) {
-  checkLoopBody(context, statement.body, /* @__PURE__ */ new Map());
-  checkExpression(context, statement.condition);
+function isFalsyLiteral(condition) {
+  if (condition.kind === "group-expression") {
+    return isFalsyLiteral(condition.expression);
+  }
+  return condition.kind === "nil-literal" || condition.kind === "boolean-literal" && !condition.value;
+}
+function hasBreak(body) {
+  return body.some((statement) => {
+    if (statement.kind === "break-statement") {
+      return true;
+    }
+    if (statement.kind === "do-statement") {
+      return hasBreak(statement.body);
+    }
+    if (statement.kind === "if-statement") {
+      return statement.clauses.some((clause) => hasBreak(clause.body)) || statement.alternate !== null && hasBreak(statement.alternate);
+    }
+    return false;
+  });
+}
+function checkWhile(context, statement) {
+  forgetAssignedPaths(context, statement.body);
+  checkExpression(context, statement.condition);
+  checkLoopBody(context, statement.body, conditionFacts(context, statement.condition));
+  context.applyFlowFacts(negatedFacts(context, statement.condition));
+  if (isTruthyLiteral(statement.condition) && !hasBreak(statement.body)) {
+    context.markUnreachable();
+  }
+}
+function checkRepeat(context, statement) {
+  checkLoopBody(context, statement.body, /* @__PURE__ */ new Map());
+  checkExpression(context, statement.condition);
+  if (isFalsyLiteral(statement.condition) && !hasBreak(statement.body)) {
+    context.markUnreachable();
+  }
 }
 function checkNumericFor(context, statement) {
   const bounds = [statement.start, statement.limit, statement.step].filter((value) => value !== null);
@@ -19505,7 +19996,31 @@ function buildFunctionType(context, parameters, returnAnnotation, contextual = n
   const names = named2.map((parameter) => parameter.name);
   return createFunction(types, context.resolveAnnotation(returnAnnotation), minimumArguments(context, parameters), isVariadic, names);
 }
-function checkFunctionBody(context, parameters, returnAnnotation, body, signature, selfType2) {
+function applyTypeParameters(context, type, names, constraints) {
+  if (names.length === 0) {
+    return type;
+  }
+  context.noteTypeParameters(names);
+  type.typeParameters = [...names];
+  type.typeConstraints = names.map((unused, index) => {
+    const constraint = constraints[index];
+    return constraint === void 0 || constraint === null ? null : context.resolveAnnotation(constraint);
+  });
+  return type;
+}
+var FALLTHROUGH_KINDS = /* @__PURE__ */ new Set(["any", "void", "nil", "optional", "unknown"]);
+function toleratesFallthrough(declared) {
+  if (FALLTHROUGH_KINDS.has(declared.kind)) {
+    return true;
+  }
+  return declared.kind === "union" && declared.options.some((option) => option.kind === "nil");
+}
+function reportMissingReturn(context, declared, position2) {
+  const name = typeToString(declared);
+  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, signature2, selfType2, position2 = ORIGIN) {
   forgetAssignedPaths(context, body);
   const entry = context.flowState;
   context.setFlow(cloneFlow(entry));
@@ -19516,16 +20031,20 @@ 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;
     }
   }
   checkStatements(context, body);
+  const declared = context.currentReturnType();
+  if (declared !== null && context.flowState.reachable && !toleratesFallthrough(declared)) {
+    reportMissingReturn(context, declared, position2);
+  }
   const inferred = context.popReturnType();
   if (returnAnnotation === null) {
-    signature.returnType = inferred;
+    signature2.returnType = inferred;
   }
   context.binder.popScope();
   context.setFlow(entry);
@@ -19616,7 +20135,8 @@ function checkAssignment(context, statement) {
   });
 }
 function checkFunctionDeclaration(context, statement) {
-  const type = buildFunctionType(context, statement.parameters, statement.returnAnnotation);
+  const built = buildFunctionType(context, statement.parameters, statement.returnAnnotation);
+  const type = applyTypeParameters(context, built, statement.typeParameters, statement.typeConstraints);
   if (statement.name.kind === "identifier") {
     const symbol = { name: statement.name.name, type, isLocal: statement.isLocal, position: statement.position };
     if (statement.isLocal) {
@@ -19626,7 +20146,7 @@ function checkFunctionDeclaration(context, statement) {
     }
   }
   context.record(statement.name, type);
-  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null);
+  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null, statement.position);
 }
 function checkReturn(context, statement) {
   const valueTypes = checkValueList(context, statement.values);
@@ -19819,36 +20339,41 @@ function checkMember(context, expression) {
   }
   return context.record(expression, extension === null ? ANY_TYPE : EXTENSION_RESULTS[extension.result]);
 }
-function countArguments(total) {
+function countArguments2(total) {
   return total === 1 ? "1 argument" : `${total} arguments`;
 }
-function checkSignature(context, args, signature, position2) {
-  const argumentTypes = checkValueList(context, args, signature.parameters);
-  if (argumentTypes.length < signature.minimumArguments) {
-    const message = `This call expects at least ${countArguments(signature.minimumArguments)} but received ${argumentTypes.length}.`;
+function checkSignature(context, args, declared, position2, owner = "This call", typeArguments = []) {
+  const argumentTypes = checkValueList(context, args, declared.parameters);
+  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 ${countArguments(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);
+  return name === null ? "This call" : `Function "${name}"`;
 }
 function checkArguments(context, expression, calleeType) {
   if (calleeType.kind !== "function") {
@@ -19856,7 +20381,7 @@ function checkArguments(context, expression, calleeType) {
     reportNotCallable(context, expression, calleeType);
     return ANY_TYPE;
   }
-  return checkSignature(context, expression.args, calleeType, expression.position);
+  return checkSignature(context, expression.args, calleeType, expression.position, callOwner(expression), expression.typeArguments);
 }
 function isSuperCall(expression) {
   return expression.method === null && expression.callee.kind === "identifier" && expression.callee.name === "super";
@@ -19866,21 +20391,24 @@ 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);
+    return checkSignature(context, expression.args, withoutSelfParameter(signature2), expression.position, callOwner(expression), expression.typeArguments);
   }
   const declared = memberOf(context, receiver, method);
   if (declared?.type.kind === "function") {
     if (declared.deprecated === true) {
       context.warn("check-deprecated-use", `Member "${method}" is deprecated.`, expression.position);
     }
-    return checkSignature(context, expression.args, declared.type, expression.position);
+    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;
   }
@@ -19941,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) {
@@ -20019,8 +20547,9 @@ function checkMultiValueExpression(context, expression, expected = null) {
     case "table-expression":
       return checkTable(context, expression);
     case "function-expression": {
-      const type = buildFunctionType(context, expression.parameters, expression.returnAnnotation, contextualFunction(expected));
-      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, type, null);
+      const built = buildFunctionType(context, expression.parameters, expression.returnAnnotation, contextualFunction(expected));
+      const type = applyTypeParameters(context, built, expression.typeParameters, expression.typeConstraints);
+      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, type, null, expression.position);
       return context.record(expression, type);
     }
     case "binary-expression": {
@@ -20109,7 +20638,7 @@ function registerMembers(context, info, statement) {
   }
   const generated = expandClassDecorators(context, statement, fieldTypes);
   for (const member of [...statement.members, ...generated]) {
-    const type = member.kind === "class-field" ? fieldTypes.get(member) ?? ANY_TYPE : member.isSynthetic ? syntheticMethodType(context, member, fieldTypes) : buildFunctionType(context, member.parameters, member.returnAnnotation);
+    const type = member.kind === "class-field" ? fieldTypes.get(member) ?? ANY_TYPE : member.isSynthetic ? syntheticMethodType(context, member, fieldTypes) : applyTypeParameters(context, buildFunctionType(context, member.parameters, member.returnAnnotation), member.typeParameters, member.typeConstraints);
     const decorators = member.decorators.map((decorator) => decorator.name);
     if (member.kind === "class-method" && isMetamethodMember(member)) {
       checkMetamethod(context, info.name, member, type);
@@ -20164,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);
+    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));
+  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;
@@ -20230,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;
 }
@@ -20344,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) {
@@ -20521,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) {
@@ -20533,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);
@@ -20674,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}`;
 }
@@ -21371,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);
   }
@@ -21383,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
@@ -21856,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, {
@@ -21886,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,
@@ -21899,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) {
@@ -21908,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
   };
 }
 
@@ -22127,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;
 }
@@ -22139,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));
   };
 }
@@ -22157,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)
   };
 }
@@ -22202,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));
@@ -22225,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,
@@ -22234,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,
@@ -22263,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;
@@ -22272,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,
@@ -22327,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);
@@ -22355,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,
@@ -22364,6 +22998,7 @@ function resourceOptions(config, inputs, minMtaVersion, developmentLogs, layout)
     configuration: inputs.configuration,
     environmentFile: config.environment.file,
     loadOrder: config.loadOrder,
+    libraryFiles,
     minMtaVersion,
     developmentLogs,
     layout,
@@ -22406,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 {
@@ -22437,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");
@@ -22462,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);
@@ -22528,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.` };
     }
@@ -22583,7 +23220,7 @@ function collectResourceMaps(directory, found) {
   }
 }
 function discoverResourceMap(root) {
-  if (!existsSync5(root)) {
+  if (!existsSync6(root)) {
     return { path: null, candidates: [] };
   }
   const found = [];
@@ -22593,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"]);
@@ -22797,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"]);
@@ -22815,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 = [];
@@ -22875,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}".`);
@@ -22883,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 });
@@ -22895,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 });
@@ -22923,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;
@@ -22953,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 {
@@ -23040,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
@@ -23094,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)}`);
@@ -23114,7 +23751,7 @@ function createProgressRenderer(reporter, options = {}) {
     if (frames > 0 && now() - lastPaintAt < throttleMs) {
       return;
     }
-    render2(event);
+    render3(event);
   }
   return {
     listen: (event) => {
@@ -23157,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);
@@ -23169,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));
@@ -23181,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) {
@@ -23195,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 {
@@ -23441,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;
   }
@@ -23600,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;
@@ -23841,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);
@@ -23871,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 {
@@ -23987,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);
@@ -24002,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()) {
@@ -24369,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";
@@ -24432,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
@@ -24448,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
@@ -24467,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)) };
@@ -24529,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,
@@ -24653,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 = [];
     }
@@ -24732,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;
@@ -24766,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'
@@ -25183,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) {
@@ -25201,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);
@@ -25280,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;
     }
   }
@@ -25305,7 +26655,7 @@ function readStandardInput() {
     return "";
   }
   try {
-    return readFileSync13(0, "utf8");
+    return readFileSync16(0, "utf8");
   } catch {
     return "";
   }
@@ -25387,6 +26737,7 @@ var COMMAND_REGISTRARS = [
   registerDevCommand,
   registerDoctorCommand,
   registerEnsureCommand,
+  registerFormatCommand,
   registerInitCommand,
   registerServerCommand,
   registerSetupCommand,