@thigasdevelopment/luam 0.19.12 → 1.0.1

package/luam.mjs

@@ -3161,6 +3161,7 @@ var DEFAULT_COMPILER_OPTIONS = {
   oop: false,
   noUnusedLocals: false,
   noUnusedParameters: false,
+  noImplicitGlobals: false,
   warningsAsErrors: false
 };
 var DEFAULT_SOURCE_MAPPING = {
@@ -3608,6 +3609,8 @@ var LUA_KEYWORDS = /* @__PURE__ */ new Set([
   "while"
 ]);
 var LUAM_KEYWORDS = /* @__PURE__ */ new Set([
+  "async",
+  "await",
   "class",
   "constructor",
   "continue",
@@ -3838,7 +3841,21 @@ function parseTypeName(stream) {
   }
   return { kind: "type-name", name: token.value, typeArguments, position: token.position };
 }
+function parseOptionalParameterType(stream) {
+  const name = stream.next().value;
+  const marker = stream.next();
+  stream.next();
+  const annotation = parseTypeAnnotation(stream);
+  if (annotation.kind === "type-optional") {
+    stream.report("parse-redundant-optional", 'The marker on the name already allows "nil". Remove the "?" after the type.', annotation.position);
+  }
+  const element = annotation.kind === "type-optional" ? annotation.element : annotation;
+  return { name, annotation: { kind: "type-optional", element, position: marker.position } };
+}
 function parseParameterType(stream) {
+  if (stream.check("identifier") && stream.checkAhead(1, "operator", "?") && stream.checkAhead(2, "punctuation", ":")) {
+    return parseOptionalParameterType(stream);
+  }
   let name = null;
   if (stream.check("identifier") && stream.checkAhead(1, "punctuation", ":")) {
     name = stream.next().value;
@@ -3889,7 +3906,7 @@ function parseGroupedType(stream) {
   return { kind: "type-tuple", elements, position: position2 };
 }
 function parseObjectMember(stream) {
-  const token = stream.expectName();
+  const token = stream.expectMemberKey();
   const annotation = parseNamedAnnotation(stream, "field");
   if (annotation === null) {
     throw stream.error(`Key "${token.value}" of an object type requires a type annotation.`, "parse-invalid-type");
@@ -4034,9 +4051,16 @@ var TokenStream = class {
   index = 0;
   erased = [];
   spans = /* @__PURE__ */ new Map();
+  breaksIndexAtNewline = false;
   constructor(tokens) {
     this.tokens = tokens;
   }
+  stopIndexAtNewline(active) {
+    this.breaksIndexAtNewline = active;
+  }
+  indexContinues(bracket) {
+    return !this.breaksIndexAtNewline || this.index === 0 || bracket.position.line === this.peek(-1).end.line;
+  }
   peek(offset = 0) {
     const token = this.tokens[Math.min(this.index + offset, this.tokens.length - 1)];
     return token;
@@ -4127,6 +4151,33 @@ var TokenStream = class {
     const token = this.peek(offset);
     return token.kind === "identifier" || token.kind === "keyword" && isLuamKeyword(token.value);
   }
+  checkMemberKey(offset = 0) {
+    return this.checkName(offset) || this.peek(offset).kind === "punctuation" && this.peek(offset).value === "[";
+  }
+  expectMemberKey() {
+    if (!this.check("punctuation", "[")) {
+      return this.expectName();
+    }
+    const open = this.next();
+    const literal2 = this.current();
+    if (literal2.kind !== "string") {
+      throw this.error(`Expected a quoted key but found "${this.describeCurrent()}".`, "parse-unexpected-token");
+    }
+    this.next();
+    const close = this.expect("punctuation", "]");
+    return { ...literal2, position: open.position, end: close.end };
+  }
+  reservedNameAt(subject, offset = 0) {
+    const token = this.peek(offset);
+    const next = this.peek(offset + 1);
+    const continues = next.kind === "punctuation" && (next.value === "," || next.value === ")" || next.value === ":") || next.kind === "operator" && (next.value === "?" || next.value === "=");
+    if (token.kind !== "keyword" || !continues) {
+      return null;
+    }
+    const message = `"${token.value}" is a reserved word and cannot name a ${subject}. Rename it \u2014 a property of the same name is still legal, so "value.${token.value}" keeps working.`;
+    this.report("parse-reserved-name", message, token.position);
+    return this.next();
+  }
   expectName() {
     if (this.checkName()) {
       return this.next();
@@ -4214,7 +4265,8 @@ function parseParameter(stream) {
     }
     return { name: name2, annotation, isVararg: true, position: token.position };
   }
-  const name = stream.expect("identifier").value;
+  const reserved = stream.reservedNameAt("parameter");
+  const name = reserved === null ? stream.expect("identifier").value : reserved.value;
   return { name, annotation: parseNamedAnnotation(stream, "parameter"), isVararg: false, position: token.position };
 }
 function parseParameters(stream) {
@@ -4229,7 +4281,20 @@ function parseParameters(stream) {
   stream.expect("punctuation", ")");
   return parameters;
 }
-function parseFunctionExpression(stream) {
+var ASYNC_MODIFIER = "async";
+function isAsyncFunctionStart(stream, offset = 0) {
+  return stream.checkAhead(offset, "keyword", ASYNC_MODIFIER) && stream.checkAhead(offset + 1, "keyword", "function");
+}
+function consumeAsyncModifier(stream) {
+  if (!isAsyncFunctionStart(stream)) {
+    return false;
+  }
+  const checkpoint = stream.checkpoint();
+  stream.next();
+  stream.eraseToCurrent(checkpoint);
+  return true;
+}
+function parseFunctionExpression(stream, isAsync = false) {
   const position2 = stream.expect("keyword", "function").position;
   const typeParameters = parseTypeParameters(stream);
   const parameters = parseParameters(stream);
@@ -4238,6 +4303,7 @@ function parseFunctionExpression(stream) {
   stream.expect("keyword", "end");
   return {
     kind: "function-expression",
+    isAsync,
     typeParameters: typeParameters.names,
     typeConstraints: typeParameters.constraints,
     parameters,
@@ -4259,7 +4325,7 @@ function parseFunctionName(stream) {
   const property = stream.expect("identifier").value;
   return { name: { kind: "member-expression", object: name, property, position: token.position }, isMethod: true };
 }
-function parseFunctionDeclaration(stream, isLocal, isExported = false, isHttpExport = false) {
+function parseFunctionDeclaration(stream, isLocal, isExported = false, isHttpExport = false, isAsync = false) {
   const position2 = stream.expect("keyword", "function").position;
   const { name, isMethod } = parseFunctionName(stream);
   const typeParameters = parseTypeParameters(stream);
@@ -4270,6 +4336,7 @@ function parseFunctionDeclaration(stream, isLocal, isExported = false, isHttpExp
   return {
     kind: "function-declaration",
     name,
+    isAsync,
     isLocal,
     isExported,
     isHttpExport,
@@ -4324,6 +4391,14 @@ function isRightAssociative(operator) {
 
 // ../compiler/src/parser/expression.ts
 var LITERAL_KEYWORDS = /* @__PURE__ */ new Set(["nil", "true", "false"]);
+var AWAIT_OPERATOR = "await";
+function isAwaitStart(stream) {
+  return stream.check("keyword", AWAIT_OPERATOR);
+}
+function parseAwaitExpression(stream) {
+  const position2 = stream.next().position;
+  return { kind: "await-expression", operand: parseSuffixed(stream), position: position2 };
+}
 function parseKeywordLiteral(token) {
   if (token.value === "nil") {
     return { kind: "nil-literal", position: token.position };
@@ -4382,6 +4457,10 @@ function parsePrimary(stream) {
     stream.next();
     return { kind: "identifier", name: token.value, position: token.position };
   }
+  if (isAsyncFunctionStart(stream)) {
+    consumeAsyncModifier(stream);
+    return parseFunctionExpression(stream, true);
+  }
   if (token.kind === "identifier") {
     stream.next();
     return { kind: "identifier", name: token.value, position: token.position };
@@ -4406,6 +4485,12 @@ function parsePrimary(stream) {
     stream.expect("punctuation", ")");
     return { kind: "group-expression", expression, position: token.position };
   }
+  if (token.kind === "keyword" && isLuamKeyword(token.value)) {
+    const message = `"${token.value}" is a reserved word and cannot be read as a value. Rename the declaration \u2014 a property of the same name is still legal, so "value.${token.value}" keeps working.`;
+    stream.report("parse-reserved-name", message, token.position);
+    stream.next();
+    return { kind: "identifier", name: token.value, position: token.position };
+  }
   throw stream.error(`Unexpected "${stream.describeCurrent()}" in expression.`, "parse-unexpected-token");
 }
 function parseArguments(stream) {
@@ -4440,6 +4525,9 @@ function parseSuffixed(stream) {
       continue;
     }
     if (token.kind === "punctuation" && token.value === "[") {
+      if (!stream.indexContinues(token)) {
+        return expression;
+      }
       stream.next();
       const index = parseExpression(stream);
       stream.expect("punctuation", "]");
@@ -4465,6 +4553,9 @@ function parseSuffixed(stream) {
   }
 }
 function parseUnary(stream) {
+  if (isAwaitStart(stream)) {
+    return parseAwaitExpression(stream);
+  }
   const token = stream.current();
   const isUnary2 = (token.kind === "operator" || token.kind === "keyword") && UNARY_OPERATORS.has(token.value);
   if (!isUnary2) {
@@ -4622,7 +4713,11 @@ function isDeclarationStart(stream) {
   if (token.value === "class") {
     return isClassHeader(stream, offset);
   }
-  return token.value === "interface" ? stream.checkAhead(offset + 2, "punctuation", "{") || stream.checkAhead(offset + 2, "keyword", "extends") : stream.checkAhead(offset + 2, "punctuation", "{");
+  if (token.value === "interface") {
+    const after = skipTypeParameters(stream, offset + 2);
+    return stream.checkAhead(after, "punctuation", "{") || stream.checkAhead(after, "keyword", "extends");
+  }
+  return stream.checkAhead(offset + 2, "punctuation", "{");
 }
 function skipDecoratorArguments(stream) {
   let depth = 0;
@@ -4652,12 +4747,14 @@ function parseDecorators(stream) {
   }
   return decorators;
 }
-function parseClassMethod(stream, token, decorators, isStatic) {
+function parseClassMethod(stream, token, decorators, isStatic, isAsync) {
   stream.expect("operator", "=");
-  const expression = parseFunctionExpression(stream);
+  const modified = consumeAsyncModifier(stream) || isAsync;
+  const expression = parseFunctionExpression(stream, modified);
   return {
     kind: "class-method",
     name: token.value,
+    isAsync: modified,
     isConstructor: token.value === "constructor",
     isSynthetic: false,
     isStatic,
@@ -4670,13 +4767,14 @@ function parseClassMethod(stream, token, decorators, isStatic) {
     position: token.position
   };
 }
-function parseBraceClassMethod(stream, token, decorators, isStatic) {
+function parseBraceClassMethod(stream, token, decorators, isStatic, isAsync) {
   const parameters = parseParameters(stream);
   const returnAnnotation = parseOptionalAnnotation(stream);
   const body = parseBraceBlock(stream);
   return {
     kind: "class-method",
     name: token.value,
+    isAsync,
     isConstructor: token.value === "constructor",
     isSynthetic: false,
     isStatic,
@@ -4692,6 +4790,14 @@ function parseBraceClassMethod(stream, token, decorators, isStatic) {
 function parseFieldAnnotation(stream) {
   return parseNamedAnnotation(stream, "field");
 }
+function parseFieldValue(stream) {
+  stream.stopIndexAtNewline(true);
+  try {
+    return parseExpression(stream);
+  } finally {
+    stream.stopIndexAtNewline(false);
+  }
+}
 function expectClassFieldBoundary(stream, token) {
   const current = stream.current();
   const delimiter = current.kind === "punctuation" && (current.value === "}" || current.value === ";" || current.value === ",");
@@ -4701,12 +4807,12 @@ function expectClassFieldBoundary(stream, token) {
   throw stream.error(`Expected a line break or separator after class member "${token.value}".`, "parse-unexpected-token");
 }
 var STATIC_MODIFIER = "static";
-function parseStaticModifier(stream) {
-  if (!stream.check("identifier", STATIC_MODIFIER)) {
+function parseMemberModifier(stream, modifier, kind = "identifier") {
+  if (!stream.check(kind, modifier)) {
     return false;
   }
-  const modifier = stream.current();
-  if (!stream.checkName(1) || stream.peek(1).position.line !== modifier.position.line) {
+  const token = stream.current();
+  if (!stream.checkName(1) || stream.peek(1).position.line !== token.position.line) {
     return false;
   }
   const checkpoint = stream.checkpoint();
@@ -4716,17 +4822,18 @@ function parseStaticModifier(stream) {
 }
 function parseClassMember(stream) {
   const decorators = parseDecorators(stream);
-  const isStatic = parseStaticModifier(stream);
-  const token = stream.expectName();
+  const isStatic = parseMemberModifier(stream, STATIC_MODIFIER);
+  const isAsync = parseMemberModifier(stream, ASYNC_MODIFIER, "keyword");
+  const token = stream.expectMemberKey();
   if (stream.check("punctuation", "(")) {
     stream.report("parse-class-method-form", `Write class member "${token.value}" as "${token.value} = function (...) ... end".`, token.position);
-    return parseBraceClassMethod(stream, token, decorators, isStatic);
+    return parseBraceClassMethod(stream, token, decorators, isStatic, isAsync);
   }
-  if (stream.check("operator", "=") && stream.checkAhead(1, "keyword", "function")) {
-    return parseClassMethod(stream, token, decorators, isStatic);
+  if (stream.check("operator", "=") && (stream.checkAhead(1, "keyword", "function") || isAsyncFunctionStart(stream, 1))) {
+    return parseClassMethod(stream, token, decorators, isStatic, isAsync);
   }
   const annotation = parseFieldAnnotation(stream);
-  const value = stream.match("operator", "=") ? parseExpression(stream) : null;
+  const value = stream.match("operator", "=") ? parseFieldValue(stream) : null;
   expectClassFieldBoundary(stream, token);
   return { kind: "class-field", name: token.value, annotation, value, decorators, isStatic, position: token.position };
 }
@@ -4739,6 +4846,7 @@ function parseClassModifiers(stream, declaration) {
     }
     do {
       declaration.interfaces.push(stream.expect("identifier").value);
+      declaration.interfaceArguments.push(parseTypeArguments(stream));
     } while (stream.match("punctuation", ","));
   }
 }
@@ -4754,6 +4862,7 @@ function parseClassDeclaration(stream, decorators) {
     superClass: null,
     superClassArguments: [],
     interfaces: [],
+    interfaceArguments: [],
     members: [],
     decorators,
     position: position2
@@ -4780,7 +4889,7 @@ function parseClassDeclaration(stream, decorators) {
   return declaration;
 }
 function parseInterfaceMember(stream) {
-  const token = stream.expectName();
+  const token = stream.expectMemberKey();
   if (stream.check("punctuation", "(")) {
     const parameters = parseParameters(stream);
     const returnAnnotation = parseOptionalAnnotation(stream);
@@ -4796,6 +4905,7 @@ function parseInterfaceDeclaration(stream) {
   const checkpoint = stream.checkpoint();
   const position2 = stream.next().position;
   const name = stream.expect("identifier").value;
+  const typeParameters = parseTypeParameters(stream);
   const superInterfaces = [];
   const members = [];
   if (stream.match("keyword", "extends")) {
@@ -4818,7 +4928,15 @@ function parseInterfaceDeclaration(stream) {
     }
   }
   stream.expect("punctuation", "}");
-  const declaration = { kind: "interface-declaration", name, superInterfaces, members, position: position2 };
+  const declaration = {
+    kind: "interface-declaration",
+    name,
+    typeParameters: typeParameters.names,
+    typeConstraints: typeParameters.constraints,
+    superInterfaces,
+    members,
+    position: position2
+  };
   stream.eraseFrom(checkpoint, "declaration");
   return declaration;
 }
@@ -4879,7 +4997,7 @@ function parseExpressionList(stream) {
   return values;
 }
 function parseDeclarator(stream) {
-  const token = stream.expect("identifier");
+  const token = stream.reservedNameAt("local") ?? stream.expect("identifier");
   return { name: token.value, annotation: parseNamedAnnotation(stream, "local"), position: token.position };
 }
 function parseLocalStatement(stream, position2) {
@@ -4973,7 +5091,34 @@ function invalidStatement(stream, target, start) {
   const message = `${subject} is not a statement. Assign it with "=", pass it to a call, or remove the line.`;
   return stream.errorAt(message, "parse-invalid-statement", start.position, start.end);
 }
+function parseGlobalDeclaration(stream) {
+  const marked = stream.checkAhead(1, "operator", "?") && stream.checkAhead(2, "punctuation", ":");
+  if (!stream.check("identifier") || !marked && !stream.checkAhead(1, "punctuation", ":")) {
+    return null;
+  }
+  const point = stream.speculate();
+  try {
+    const declaration = parseDeclarator(stream);
+    if (declaration.annotation !== null && stream.match("operator", "=")) {
+      return { kind: "global-statement", declaration, values: parseExpressionList(stream), position: declaration.position };
+    }
+  } catch (error) {
+    if (!(error instanceof ParserError)) {
+      throw error;
+    }
+  }
+  stream.rewind(point);
+  return null;
+}
 function parseExpressionStatement(stream) {
+  if (isAwaitStart(stream)) {
+    const expression = parseAwaitExpression(stream);
+    return { kind: "call-statement", expression, position: expression.position };
+  }
+  const declaration = parseGlobalDeclaration(stream);
+  if (declaration !== null) {
+    return declaration;
+  }
   const start = stream.current();
   const position2 = start.position;
   const targets = [parseSuffixed(stream)];
@@ -5001,7 +5146,12 @@ function parseKeywordStatement(stream, value) {
     if (stream.check("keyword", "function")) {
       return parseFunctionDeclaration(stream, true);
     }
-    return stream.check("keyword", "enum") ? parseEnumDeclaration(stream, true) : parseLocalStatement(stream, token.position);
+    if (isAsyncFunctionStart(stream)) {
+      consumeAsyncModifier(stream);
+      return parseFunctionDeclaration(stream, true, false, false, true);
+    }
+    const isEnum = stream.check("keyword", "enum") && stream.checkAhead(1, "identifier");
+    return isEnum ? parseEnumDeclaration(stream, true) : parseLocalStatement(stream, token.position);
   }
   if (value === "function") {
     return parseFunctionDeclaration(stream, false);
@@ -5042,6 +5192,10 @@ function parseStatement(stream) {
       return statement;
     }
   }
+  if (isAsyncFunctionStart(stream)) {
+    consumeAsyncModifier(stream);
+    return parseFunctionDeclaration(stream, false, false, false, true);
+  }
   if (isTypeAlias(stream)) {
     return parseTypeAlias(stream);
   }
@@ -5266,10 +5420,21 @@ function isEmptyLiteral(type) {
   return type.kind === "record" && type.isLiteral === true && type.members.size === 0;
 }
 function widenInferred(type) {
+  if (type.kind === "array") {
+    return createArray(widenInferred(type.element));
+  }
+  if (type.kind === "union") {
+    return createUnion(type.options.map(widenInferred));
+  }
   if (type.kind !== "record" || type.isLiteral !== true) {
     return widenLiteral(type);
   }
-  return type.members.size === 0 ? TABLE_TYPE : createRecord(type.name, type.members, type.origin);
+  if (type.members.size === 0) {
+    return TABLE_TYPE;
+  }
+  const widened = new Map([...type.members].map(([name, member]) => [name, widenInferred(member)]));
+  const record2 = createObjectType(widened);
+  return record2.kind === "record" ? { ...record2, isInferred: true } : record2;
 }
 function createFunction(parameters, returnType, minimumArguments2, isVariadic = false, parameterNames, variadicType) {
   return {
@@ -5428,7 +5593,7 @@ function isFunctionAssignable(source, target, options) {
   return target.returnType.kind === "void" || isAssignable(source.returnType, target.returnType, options);
 }
 function isMapAssignable(source, target, options) {
-  if (source.kind === "table") {
+  if (source.kind === "table" || isEmptyLiteral(source)) {
     return true;
   }
   if (source.kind === "array") {
@@ -5677,9 +5842,16 @@ var RUNTIME_HELPERS = {
   },
   env: { name: "env", file: "env.lua", injection: "manual", features: [], environment: "server" },
   math: { name: "math", file: "math.lua", injection: "automatic", features: ["number-extension"] },
+  promise: {
+    name: "promise",
+    file: "promise.lua",
+    injection: "reference",
+    features: ["async-function"],
+    globals: ["Promise", "delay", "sleep"]
+  },
   string: { name: "string", file: "string.lua", injection: "automatic", features: ["string-extension", "template-string"] },
   table: { name: "table", file: "table.lua", injection: "automatic", features: ["table-extension"] },
-  threads: { name: "threads", file: "threads.lua", injection: "reference", features: ["thread"], globals: ["sleep", "Threads"] },
+  threads: { name: "threads", file: "threads.lua", injection: "reference", features: ["thread"], globals: ["Threads"], requires: ["promise"] },
   validate: { name: "validate", file: "validate.lua", injection: "automatic", features: ["boundary-validation"] }
 };
 var DEVELOPMENT_RUNTIME_HELPERS = {
@@ -5741,6 +5913,9 @@ var COMPILER_OPTION_FIELDS = [
   }),
   field("oop", BOOLEAN_TYPE, "Enables the MTA OOP API in the checker and the generated meta.xml.", { defaultValue: DEFAULT_COMPILER_OPTIONS.oop }),
   field("noUnusedLocals", BOOLEAN_TYPE, "Reports local declarations that are never read.", { defaultValue: DEFAULT_COMPILER_OPTIONS.noUnusedLocals }),
+  field("noImplicitGlobals", BOOLEAN_TYPE, "Reports an assignment that creates a global the project never declares.", {
+    defaultValue: DEFAULT_COMPILER_OPTIONS.noImplicitGlobals
+  }),
   field("noUnusedParameters", BOOLEAN_TYPE, "Reports function and method parameters that are never read.", {
     defaultValue: DEFAULT_COMPILER_OPTIONS.noUnusedParameters
   }),
@@ -6802,6 +6977,7 @@ function readCompilerOptions(value) {
     strict: flag(source, "strict", DEFAULT_COMPILER_OPTIONS.strict),
     oop: flag(source, "oop", DEFAULT_COMPILER_OPTIONS.oop),
     noUnusedLocals: flag(source, "noUnusedLocals", DEFAULT_COMPILER_OPTIONS.noUnusedLocals),
+    noImplicitGlobals: flag(source, "noImplicitGlobals", DEFAULT_COMPILER_OPTIONS.noImplicitGlobals),
     noUnusedParameters: flag(source, "noUnusedParameters", DEFAULT_COMPILER_OPTIONS.noUnusedParameters),
     warningsAsErrors: flag(source, "warningsAsErrors", DEFAULT_COMPILER_OPTIONS.warningsAsErrors)
   };
@@ -6978,7 +7154,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.19.12" : "0.0.0-dev";
+var VERSION = true ? "1.0.1" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -7042,7 +7218,7 @@ function runEditorCommand(command, args) {
 }
 
 // src/editor/editor-service.ts
-var EXTENSION_ID = "thigasdevelopment.luam";
+var EXTENSION_ID = "luam.luam";
 var SUPPORTED_EDITORS = [
   { id: "vscode", name: "Visual Studio Code", command: "code" },
   { id: "vscode-insiders", name: "Visual Studio Code Insiders", command: "code-insiders" },
@@ -8862,12 +9038,13 @@ var TEST_DECLARATIONS = [
 
 // ../compiler/src/checker/ambient.ts
 var EVENT_NAME_PREFIX = "event:";
-var EMPTY_AMBIENT = { classes: [], interfaces: [], enums: [], globals: [], events: [] };
+var EMPTY_AMBIENT = { classes: [], interfaces: [], enums: [], aliases: [], globals: [], events: [] };
 function ambientFromRegistry(registry) {
   return {
     classes: registry.allClasses(),
-    interfaces: registry.allInterfaces(),
+    interfaces: registry.allInterfaces().filter((info) => info.isBuiltin !== true),
     enums: registry.allEnums().filter((info) => info.isLocal !== true),
+    aliases: registry.allAliases(),
     globals: registry.allGlobals(),
     events: registry.allEvents()
   };
@@ -8885,6 +9062,7 @@ function ownDeclarations(registry, ambient) {
     classes: withoutNames(all.classes, ambient.classes),
     interfaces: withoutNames(all.interfaces, ambient.interfaces),
     enums: withoutNames(all.enums, ambient.enums),
+    aliases: withoutNames(all.aliases, ambient.aliases),
     globals: withoutNames(all.globals, ambient.globals),
     events: withoutNames(all.events, ambient.events)
   };
@@ -8903,6 +9081,7 @@ function mergeAmbient(sources) {
     classes: mergeByName(sources.map((source) => source.classes)),
     interfaces: mergeByName(sources.map((source) => source.interfaces)),
     enums: mergeByName(sources.map((source) => source.enums)),
+    aliases: mergeByName(sources.map((source) => source.aliases)),
     globals: mergeByName(sources.map((source) => source.globals)),
     events: mergeByName(sources.map((source) => source.events))
   };
@@ -8977,6 +9156,9 @@ function declareAll(catalog, environment, source) {
 function isAvailableIn(declared, environment) {
   return declared === "shared" || declared === environment;
 }
+function isVisibleIn(declared, environment) {
+  return environment === "shared" || isAvailableIn(declared, environment);
+}
 
 // ../compiler/src/checker/api-types.ts
 var PRIMITIVES = {
@@ -9028,6 +9210,74 @@ function descriptorToType(descriptor) {
   return PRIMITIVES[descriptor.kind] ?? ANY_TYPE;
 }
 
+// ../compiler/src/checker/async.ts
+var PROMISE_TYPE = "Promise";
+var SLEEP_FUNCTION = "sleep";
+var PROMISE_PARAMETER = "T";
+var ORIGIN = { line: 0, column: 0, offset: 0 };
+var AWAIT_OUTSIDE_MESSAGE = '"await" is only valid inside an async function. Declare the function "async function name()", or wait on the promise with ":next(...)".';
+var ASYNC_ANNOTATION_MESSAGE = 'An async function is annotated with the type it resolves to, not with "Promise". Write the inner type and the signature becomes a promise of it.';
+var SLEEP_OUTSIDE_MESSAGE = '"sleep" suspends a coroutine and there is none here. Declare the function "async function name()", or run the body as a thread pool job.';
+function promiseOf(inner) {
+  return createNamed(PROMISE_TYPE, [inner]);
+}
+function isPromiseType(type) {
+  return (type.kind === "named" || type.kind === "record") && type.name === PROMISE_TYPE;
+}
+function declarePromiseType(declarations) {
+  const value = createNamed(PROMISE_PARAMETER);
+  const onFulfilled = createFunction([value], ANY_TYPE, 1, false, ["value"]);
+  const onRejected = createFunction([ANY_TYPE], ANY_TYPE, 1, false, ["reason"]);
+  const chained = promiseOf(ANY_TYPE);
+  const next = createFunction([onFulfilled, createOptional(onRejected)], chained, 1, false, ["onFulfilled", "onRejected"]);
+  const failure3 = createFunction([onRejected], chained, 1, false, ["onRejected"]);
+  declarations.declareInterface({
+    name: PROMISE_TYPE,
+    isBuiltin: true,
+    typeParameters: [PROMISE_PARAMETER],
+    typeConstraints: [null],
+    superInterfaces: [],
+    members: /* @__PURE__ */ new Map([
+      ["next", { name: "next", type: next, isMethod: true, position: ORIGIN }],
+      ["catch", { name: "catch", type: failure3, isMethod: true, position: ORIGIN }]
+    ]),
+    position: ORIGIN
+  });
+}
+function awaitedType(context, operand, expression) {
+  if (!context.inAsyncBody()) {
+    context.report("check-await-outside-async", AWAIT_OUTSIDE_MESSAGE, expression.position);
+    return ANY_TYPE;
+  }
+  if (operand.kind === "any" || operand.kind === "unknown") {
+    return ANY_TYPE;
+  }
+  if (isPromiseType(operand)) {
+    return (operand.kind === "named" ? operand.typeArguments?.[0] : ANY_TYPE) ?? ANY_TYPE;
+  }
+  const message = `"await" expects a promise but received "${typeToString(operand)}". Only an async function or "new Promise(...)" produces one.`;
+  context.report("check-await-non-promise", message, expression.position);
+  return ANY_TYPE;
+}
+function isPromiseAnnotation(isAsync, annotation) {
+  return isAsync && annotation !== null && annotation.kind === "type-name" && annotation.name === PROMISE_TYPE;
+}
+function asyncInnerAnnotation(isAsync, annotation) {
+  return isPromiseAnnotation(isAsync, annotation) ? null : annotation;
+}
+function reportAsyncAnnotation(context, isAsync, annotation) {
+  if (!isPromiseAnnotation(isAsync, annotation) || annotation === null) {
+    return;
+  }
+  context.report("check-async-return-annotation", ASYNC_ANNOTATION_MESSAGE, annotation.position);
+}
+function reportSleepOutsideAsync(context, name, position2) {
+  if (name !== SLEEP_FUNCTION || context.declaredGlobals.has(name) || context.binder.lookup(name)?.isLocal === true || context.suspendable()) {
+    return;
+  }
+  context.warn("check-sleep-outside-async", SLEEP_OUTSIDE_MESSAGE, position2);
+}
+
 // ../compiler/src/checker/binder.ts
 var Binder = class {
   scopes = [/* @__PURE__ */ new Map()];
@@ -9195,6 +9445,9 @@ var MAX_DEPTH = 32;
 function classSubstitutions(info, typeArguments) {
   return new Map(info.typeParameters.map((parameter, index) => [parameter, typeArguments[index] ?? ANY_TYPE]));
 }
+function parameterSubstitutions(typeParameters, typeArguments) {
+  return new Map(typeParameters.map((parameter, index) => [parameter, typeArguments[index] ?? ANY_TYPE]));
+}
 function parentSubstitutions(registry, info, current) {
   const parent = info.superClass === null ? null : registry.lookupClass(info.superClass);
   if (parent === null) {
@@ -9222,7 +9475,15 @@ function substitutionsFor(registry, receiver, owner) {
   }
   return /* @__PURE__ */ new Map();
 }
+function interfaceSubstitutions(registry, receiver) {
+  const contract = registry.lookupInterface(receiver.name);
+  return contract === null ? null : parameterSubstitutions(contract.typeParameters, receiver.typeArguments ?? []);
+}
 function specializeMember(context, receiver, member, property) {
+  const contract = interfaceSubstitutions(context.declarations, receiver);
+  if (contract !== null) {
+    return contract.size === 0 ? member : { ...member, type: substituteType(member.type, contract) };
+  }
   const owner = context.declarations.lookupMemberOwner(receiver.name, property);
   if (owner === null || owner === receiver.name) {
     const own = context.declarations.lookupClass(receiver.name);
@@ -9307,6 +9568,11 @@ function reportConstraintViolations(context, owner, typeParameters, typeConstrai
   });
 }
 function checkTypeConstraints(context, name, typeArguments, position2) {
+  const contract = context.declarations.lookupInterface(name);
+  if (contract !== null) {
+    reportConstraintViolations(context, `interface "${name}"`, contract.typeParameters, contract.typeConstraints, typeArguments, position2);
+    return;
+  }
   const info = context.declarations.lookupClass(name);
   if (info === null) {
     return;
@@ -9343,6 +9609,17 @@ var LUA_GLOBALS = {
 };
 
 // ../mta-types/src/luam-runtime.ts
+var PROMISE_VALUE = named("Promise");
+var RESOLVE = fn([ANY], VOID, 0, true, ["values"]);
+var REJECT = fn([ANY], VOID, 0, true, ["reason"]);
+var EXECUTOR = fn([RESOLVE, REJECT], ANY, 2, false, ["resolve", "reject"]);
+var ON_FULFILLED = fn([ANY], ANY, 0, true, ["value"]);
+var ON_REJECTED = fn([ANY], ANY, 1, false, ["reason"]);
+var PROMISE = record("Promise", [
+  { name: "next", type: fn([ON_FULFILLED, optionalOf(ON_REJECTED)], PROMISE_VALUE, 1, false, ["onFulfilled", "onRejected"]) },
+  { name: "catch", type: fn([ON_REJECTED], PROMISE_VALUE, 1, false, ["onRejected"]) }
+]);
+var JOB = tupleOf([NUMBER, PROMISE]);
 var THREAD = record("Thread", [
   { name: "get", type: fn([], NUMBER, 0) },
   { name: "set", type: fn([NUMBER], BOOLEAN, 1) },
@@ -9351,8 +9628,10 @@ var THREAD = record("Thread", [
   { name: "isPaused", type: fn([], BOOLEAN, 0) },
   { name: "isStarted", type: fn([], BOOLEAN, 0) }
 ]);
+var JOB_BODY = fn([THREAD], ANY, 0, true, ["thread"]);
+var TASK_BODY = fn([ANY], ANY, 0, true, ["values"]);
 var THREADS = record("Threads", [
-  { name: "add", type: fn([ANY, TABLE], NUMBER, 1, true) },
+  { name: "add", type: fn([JOB_BODY, TABLE], JOB, 1, true, ["target", "options"]) },
   { name: "remove", type: fn([NUMBER], BOOLEAN, 1) },
   { name: "clear", type: fn([], BOOLEAN, 0) },
   { name: "start", type: fn([], BOOLEAN, 0) },
@@ -9360,18 +9639,31 @@ var THREADS = record("Threads", [
   { name: "getType", type: fn([], STRING, 0) }
 ]);
 var ASYNC = record("Async", [
-  { name: "map", type: fn([TABLE, ANY, ANY], NUMBER, 2) },
-  { name: "iterate", type: fn([NUMBER, NUMBER, NUMBER, ANY, ANY], NUMBER, 4) },
-  { name: "foreach", type: fn([TABLE, ANY, ANY], NUMBER, 2) },
+  { name: "map", type: fn([TABLE, ANY, ANY], JOB, 2) },
+  { name: "iterate", type: fn([NUMBER, NUMBER, NUMBER, ANY, ANY], JOB, 4) },
+  { name: "foreach", type: fn([TABLE, ANY, ANY], JOB, 2) },
   { name: "getInterval", type: fn([], NUMBER, 0) },
   { name: "setInterval", type: fn([NUMBER], BOOLEAN, 1) }
 ]);
+var PROMISE_LIBRARY = record("PromiseLibrary", [
+  { name: "new", type: fn([EXECUTOR], PROMISE, 1, false, ["executor"]) },
+  { name: "spawn", type: fn([TASK_BODY], PROMISE, 1, true, ["target"]) },
+  { name: "resolve", type: fn([ANY], PROMISE, 0, true) },
+  { name: "reject", type: fn([ANY], PROMISE, 0, true) },
+  { name: "all", type: fn([arrayOf(ANY)], PROMISE, 1) },
+  { name: "race", type: fn([arrayOf(ANY)], PROMISE, 1) },
+  { name: "settle", type: fn([PROMISE], tupleOf([BOOLEAN, ANY]), 1) },
+  { name: "await", type: fn([PROMISE], ANY, 1) },
+  { name: "delay", type: fn([NUMBER], PROMISE, 1) }
+]);
 var LUAM_RUNTIME_SERVER_GLOBALS = {};
 var LUAM_RUNTIME_GLOBALS = {
   bind: fn([ANY, ANY], ANY, 2),
   getClass: fn([STRING], optionalOf(TABLE), 1),
   getClasses: fn([], TABLE, 0),
   sleep: fn([NUMBER], ANY, 1),
+  delay: fn([NUMBER], PROMISE, 1),
+  Promise: PROMISE_LIBRARY,
   Thread: THREAD,
   Threads: record("ThreadsLibrary", [{ name: "new", type: fn([STRING, STRING], THREADS, 0) }]),
   Async: record("AsyncLibrary", [{ name: "new", type: fn([NUMBER], ASYNC, 0) }])
@@ -12233,10 +12525,14 @@ var MTA_EXACT = {
   client: MTA_CLIENT_GLOBALS
 };
 function globalsFor(environment) {
-  return DECLARATIONS.flatMap((declaration) => {
+  const resolved2 = /* @__PURE__ */ new Map();
+  for (const declaration of DECLARATIONS) {
     const exact = findDeclaration(declaration.name, environment);
-    return exact === null ? [] : [exact];
-  });
+    if (exact !== null && !resolved2.has(exact.name)) {
+      resolved2.set(exact.name, exact);
+    }
+  }
+  return [...resolved2.values()];
 }
 function findDeclaration(name, environment) {
   const declaration = BY_NAME.get(name);
@@ -12244,7 +12540,7 @@ function findDeclaration(name, environment) {
     return declaration ?? null;
   }
   if (!isAvailableIn(declaration.environment, environment)) {
-    return null;
+    return environment === "shared" ? declaration : null;
   }
   if (declaration.source !== "mta") {
     return declaration;
@@ -14049,11 +14345,15 @@ var DeclarationRegistry = class {
   classes = /* @__PURE__ */ new Map();
   interfaces = /* @__PURE__ */ new Map();
   enums = /* @__PURE__ */ new Map();
+  aliases = /* @__PURE__ */ new Map();
   globals = /* @__PURE__ */ new Map();
   events = /* @__PURE__ */ new Map();
   declareGlobal(info) {
     this.globals.set(info.name, info);
   }
+  lookupGlobal(name) {
+    return this.globals.get(name) ?? null;
+  }
   allGlobals() {
     return [...this.globals.values()];
   }
@@ -14089,6 +14389,15 @@ var DeclarationRegistry = class {
   declareEnum(info) {
     this.enums.set(info.name, info);
   }
+  declareAlias(info) {
+    this.aliases.set(info.name, info);
+  }
+  lookupAlias(name) {
+    return this.aliases.get(name) ?? null;
+  }
+  allAliases() {
+    return [...this.aliases.values()];
+  }
   lookupEnum(name) {
     return this.enums.get(name) ?? null;
   }
@@ -14229,6 +14538,7 @@ function buildRegistry() {
       superClass: declaration.parent,
       superArguments: [],
       interfaces: [],
+      interfaceArguments: [],
       members,
       statics: /* @__PURE__ */ new Map(),
       position: MTA_POSITION
@@ -14430,16 +14740,23 @@ var CheckContext = class {
   isDeclarationFile = false;
   returnStack = [];
   methodStack = [];
+  functionStack = [];
   projectEnvironments = /* @__PURE__ */ new Map();
   predeclared = /* @__PURE__ */ new Map();
   ambientClasses = /* @__PURE__ */ new Set();
   ambientInterfaces = /* @__PURE__ */ new Set();
   ambientEnums = /* @__PURE__ */ new Set();
+  ambientAliases = /* @__PURE__ */ new Set();
+  ambientGlobals = /* @__PURE__ */ new Set();
+  obligations = /* @__PURE__ */ new Map();
+  blockDepth = 0;
+  noImplicitGlobals = false;
   constructor(mode, environment, ambient = EMPTY_AMBIENT, project = EMPTY_PROJECT_DECLARATIONS, oop = false) {
     this.mode = mode;
     this.environment = environment;
     this.mtaClasses = oop ? mtaClassRegistry() : null;
     this.binder.useBuiltins(builtinSymbols(environment));
+    declarePromiseType(this.declarations);
     this.declareProject(project);
     this.declareAmbient(ambient);
   }
@@ -14510,6 +14827,24 @@ var CheckContext = class {
   isAmbientEnum(name) {
     return this.ambientEnums.has(name);
   }
+  isAmbientAlias(name) {
+    return this.ambientAliases.has(name);
+  }
+  isAmbientGlobal(name) {
+    return this.ambientGlobals.has(name);
+  }
+  openRecordObligation(obligation) {
+    this.obligations.set(obligation.path, obligation);
+  }
+  recordObligation(path) {
+    return this.obligations.get(path) ?? null;
+  }
+  closeRecordObligation(path) {
+    this.obligations.delete(path);
+  }
+  recordObligationPaths() {
+    return [...this.obligations.keys()];
+  }
   noteExternalReference(name, position2) {
     if (!this.externalReferences.has(name)) {
       this.externalReferences.set(name, position2);
@@ -14595,6 +14930,18 @@ var CheckContext = class {
   currentClassMethod() {
     return this.methodStack[this.methodStack.length - 1] ?? null;
   }
+  pushFunctionFrame(frame) {
+    this.functionStack.push(frame);
+  }
+  popFunctionFrame() {
+    this.functionStack.pop();
+  }
+  inAsyncBody() {
+    return this.functionStack[this.functionStack.length - 1]?.isAsync === true;
+  }
+  suspendable() {
+    return this.functionStack.some((frame) => frame.isAsync || frame.isExpression);
+  }
   resolveAnnotation(annotation) {
     if (annotation === null) {
       return ANY_TYPE;
@@ -14679,19 +15026,28 @@ var CheckContext = class {
   assignability() {
     return { allowNil: this.allowNil, resolveNominal: (name) => this.nominalShape(name) };
   }
-  expectAssignable(source, target, position2, subject) {
+  resolveValueAnnotation(annotation, subject) {
+    const resolved2 = this.resolveAnnotation(annotation);
+    if (resolved2.kind !== "tuple") {
+      return resolved2;
+    }
+    const message = `A parenthesised list like "${typeToString(resolved2)}" is a return shape and cannot type ${subject}. Name one type instead.`;
+    this.report("check-tuple-position", message, annotation.position);
+    return firstValueOf(resolved2);
+  }
+  expectAssignable(source, target, position2, subject, printed = target) {
     if (isAssignable(source, target, this.assignability())) {
       return;
     }
     const received = isLiteralType(target) || target.kind === "union" ? source : widenLiteral(source);
-    const message = `${subject} expects "${typeToString(target)}" but received "${typeToString(received)}".`;
+    const message = `${subject} expects "${typeToString(printed)}" but received "${typeToString(received)}".`;
     const hint = `${nilHint(source, target, this.mode)}${missingKeyHint(source, target, (name) => this.nominalShape(name))}`;
     this.report("check-type-mismatch", `${message}${hint}`, position2);
   }
   declareProject(project) {
     for (const declaration of project.globals) {
       this.projectEnvironments.set(declaration.name, declaration.environment);
-      if (isAvailableIn(declaration.environment, this.environment)) {
+      if (isVisibleIn(declaration.environment, this.environment)) {
         const symbol = { name: declaration.name, type: descriptorToType(declaration.type), isLocal: false, position: PROJECT_POSITION };
         this.binder.declareGlobal(symbol);
       }
@@ -14712,7 +15068,14 @@ var CheckContext = class {
       this.declarations.declareEnum(info);
       this.binder.declareGlobal({ name: info.name, type: createNamed(info.name), isLocal: false, position: info.position });
     }
+    for (const info of ambient.aliases) {
+      this.ambientAliases.add(info.name);
+      this.binder.declareAlias(info.name, info.type, info.typeParameters);
+      this.declarations.declareAlias(info);
+    }
     for (const info of ambient.globals) {
+      this.ambientGlobals.add(info.name);
+      this.declarations.declareGlobal(info);
       this.binder.declareGlobal({ name: info.name, type: info.type, isLocal: false, position: info.position });
     }
     for (const info of ambient.events) {
@@ -14732,18 +15095,20 @@ var CheckContext = class {
     return createMap(this.resolveAnnotation(key), this.resolveAnnotation(value));
   }
   resolveClassAnnotation(name, typeArguments, position2) {
-    const declared = this.declarations.lookupClass(name)?.typeParameters ?? [];
+    const declaredInterface = this.declarations.lookupInterface(name);
+    const owner = declaredInterface === null ? "Class" : "Interface";
+    const declared = declaredInterface?.typeParameters ?? this.declarations.lookupClass(name)?.typeParameters ?? [];
     const resolved2 = typeArguments.map((argument) => this.resolveAnnotation(argument));
     if (declared.length === 0) {
       return createNamed(name);
     }
     if (resolved2.length !== declared.length) {
       const expected = declared.length === 1 ? "1 type argument" : `${declared.length} type arguments`;
-      this.report("check-generic-arity", `Class "${name}" expects ${expected} but received ${resolved2.length}.`, position2);
+      this.report("check-generic-arity", `${owner} "${name}" expects ${expected} but received ${resolved2.length}.`, position2);
     }
     const specialized = createNamed(name, declared.map((unused, index) => resolved2[index] ?? ANY_TYPE));
     if (namedNesting(specialized) > MAX_GENERIC_DEPTH) {
-      const message = `Class "${name}" is nested more than ${MAX_GENERIC_DEPTH} levels deep here. Name the inner type with a "type" alias.`;
+      const message = `${owner} "${name}" is nested more than ${MAX_GENERIC_DEPTH} levels deep here. Name the inner type with a "type" alias.`;
       this.report("check-generic-depth", message, position2);
       return createNamed(name);
     }
@@ -14789,6 +15154,7 @@ var ALLOWED = /* @__PURE__ */ new Set([
 var LABELS = {
   "local-statement": 'A "local" declaration',
   "assignment-statement": "An assignment",
+  "global-statement": "A global declaration",
   "call-statement": "A call",
   "return-statement": 'A "return"',
   "break-statement": 'A "break"',
@@ -14837,6 +15203,7 @@ function childExpressions(expression) {
     case "binary-expression":
       return [expression.left, expression.right];
     case "unary-expression":
+    case "await-expression":
       return [expression.operand];
     case "group-expression":
       return [expression.expression];
@@ -14848,6 +15215,7 @@ function statementExpressions(statement) {
   switch (statement.kind) {
     case "local-statement":
     case "return-statement":
+    case "global-statement":
       return statement.values;
     case "assignment-statement":
       return [...statement.targets, ...statement.values];
@@ -14995,18 +15363,28 @@ function checkContract(context, info, contract, member) {
   const message = `${subject} expects "${typeToString(member.type)}" from interface "${contract}" but is "${typeToString(actual.type)}".`;
   context.report("check-unimplemented-interface", message, actual.position);
 }
+function contractName(name, typeArguments) {
+  return typeArguments.length === 0 ? name : `${name}<${typeArguments.map(typeToString).join(", ")}>`;
+}
 function checkInterfaces(context, info) {
-  for (const name of info.interfaces) {
+  info.interfaces.forEach((name, index) => {
     const contract = context.declarations.lookupInterface(name);
     if (contract === null) {
       context.noteExternalReference(name, info.position);
       context.report("check-unknown-interface", `Class "${info.name}" implements "${name}", which is not defined.`, info.position);
-      continue;
+      return;
+    }
+    const typeArguments = info.interfaceArguments[index] ?? [];
+    if (contract.typeParameters.length > 0 && typeArguments.length !== contract.typeParameters.length) {
+      const expected = contract.typeParameters.length === 1 ? "1 type argument" : `${contract.typeParameters.length} type arguments`;
+      context.report("check-generic-arity", `Interface "${name}" expects ${expected} but received ${typeArguments.length}.`, info.position);
     }
+    const substitutions = parameterSubstitutions(contract.typeParameters, typeArguments);
+    const label2 = contractName(name, typeArguments);
     for (const member of context.declarations.collectInterfaceContract(contract.name)) {
-      checkContract(context, info, name, member);
+      checkContract(context, info, label2, substitutions.size === 0 ? member : { ...member, type: substituteType(member.type, substitutions) });
     }
-  }
+  });
 }
 function checkOverrides(context, info, statement) {
   for (const member of statement.members) {
@@ -15401,6 +15779,7 @@ function accessorMethod(field2, decorator, name) {
   return {
     kind: "class-method",
     name,
+    isAsync: false,
     isConstructor: false,
     isSynthetic: true,
     isStatic: false,
@@ -15414,7 +15793,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, typeParameters: [], typeConstraints: [], parameters, returnAnnotation, body: [], decorators: [], generated: { kind, fields }, position: field2.position };
+  return { kind: "class-method", name, isAsync: false, 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 };
@@ -15449,6 +15828,7 @@ function staticMethod(statement, name, returnAnnotation, kind, descriptor) {
   return {
     kind: "class-method",
     name,
+    isAsync: false,
     isConstructor: false,
     isSynthetic: true,
     isStatic: true,
@@ -15604,6 +15984,7 @@ function childExpressions2(expression) {
     case "binary-expression":
       return [expression.left, expression.right];
     case "unary-expression":
+    case "await-expression":
       return [expression.operand];
     case "group-expression":
       return [expression.expression];
@@ -15615,6 +15996,7 @@ function statementExpressions2(statement) {
   switch (statement.kind) {
     case "local-statement":
     case "return-statement":
+    case "global-statement":
       return statement.values;
     case "assignment-statement":
       return [...statement.targets, ...statement.values];
@@ -15672,6 +16054,9 @@ function addTargets(statement, paths) {
   if (statement.kind === "local-statement") {
     statement.declarations.forEach((declaration) => paths.add(declaration.name));
   }
+  if (statement.kind === "global-statement") {
+    paths.add(statement.declaration.name);
+  }
 }
 function collectPaths(body, paths) {
   for (const statement of body) {
@@ -19083,21 +19468,42 @@ function eventHandler(name, environment) {
   return MTA_EVENT_SIGNATURES[environment][name] ?? null;
 }
 
-// ../compiler/src/checker/environment-checks.ts
-var EVENT_FUNCTIONS = /* @__PURE__ */ new Set(["addEventHandler", "removeEventHandler", "triggerEvent"]);
+// ../compiler/src/checker/environment-message.ts
 function scopeLabel(environment) {
   return environment === "shared" ? "shared" : `${environment}-only`;
 }
+function unavailableTail(environment) {
+  return `is not available in a "${environment}" file.`;
+}
+function unusableTail(environment) {
+  return `cannot be used in a "${environment}" file.`;
+}
+function reportEnvironment(context, code, message, position2) {
+  if (context.environment === "shared") {
+    return;
+  }
+  context.report(code, message, position2);
+}
+
+// ../compiler/src/checker/environment-checks.ts
+var EVENT_FUNCTIONS = /* @__PURE__ */ new Set(["addEventHandler", "removeEventHandler", "triggerEvent"]);
+function reportProject(context, name, declared, position2) {
+  const message = `"${name}" is declared by the project, is ${scopeLabel(declared)}, and ${unavailableTail(context.environment)}`;
+  reportEnvironment(context, "check-environment-api", message, position2);
+}
+function reportApi(context, name, declared, position2) {
+  const message = `API "${name}" is ${scopeLabel(declared)} and ${unavailableTail(context.environment)}`;
+  reportEnvironment(context, "check-environment-api", message, position2);
+}
 function checkGlobalReference(context, name, position2) {
   if (name === "self") {
-    const message2 = 'A "self" is only bound inside a class method or a "function Name:method()"; here it reads a global that is "nil".';
-    context.report("check-invalid-self", message2, position2);
+    const message = 'A "self" is only bound inside a class method or a "function Name:method()"; here it reads a global that is "nil".';
+    context.report("check-invalid-self", message, position2);
     return;
   }
   const project = context.projectEnvironmentOf(name);
   if (project !== null) {
-    const message2 = `"${name}" is declared by the project, is ${scopeLabel(project)}, and is not available in a "${context.environment}" file.`;
-    context.report("check-environment-api", message2, position2);
+    reportProject(context, name, project, position2);
     return;
   }
   const declared = declarationEnvironment(name);
@@ -19105,8 +19511,26 @@ function checkGlobalReference(context, name, position2) {
     context.noteExternalReference(name, position2);
     return;
   }
-  const message = `API "${name}" is ${scopeLabel(declared)} and is not available in a "${context.environment}" file.`;
-  context.report("check-environment-api", message, position2);
+  reportApi(context, name, declared, position2);
+}
+function checkSharedReference(context, name, position2) {
+  if (context.environment !== "shared" || context.moduleGlobals.has(name)) {
+    return;
+  }
+  const project = context.projectEnvironmentOf(name);
+  if (project !== null) {
+    if (project !== "shared") {
+      reportProject(context, name, project, position2);
+    }
+    return;
+  }
+  if (!context.binder.isBuiltinReference(name)) {
+    return;
+  }
+  const declared = declarationEnvironment(name);
+  if (declared !== null && declared !== "shared") {
+    reportApi(context, name, declared, position2);
+  }
 }
 function eventName(expression) {
   const argument = expression.args[0];
@@ -19125,8 +19549,8 @@ function checkEventUsage(context, expression) {
   if (name === null || custom?.environment === "shared" || custom?.environment === context.environment || declared === null || declared === context.environment) {
     return;
   }
-  const message = `Event "${name}" is ${scopeLabel(declared)} and cannot be used in a "${context.environment}" file.`;
-  context.report("check-environment-event", message, expression.position);
+  const message = `Event "${name}" is ${scopeLabel(declared)} and ${unusableTail(context.environment)}`;
+  reportEnvironment(context, "check-environment-event", message, expression.position);
 }
 
 // ../mta-types/src/event-call-semantics.ts
@@ -19307,6 +19731,136 @@ function withoutSelfParameter(signature2) {
   return createFunction(signature2.parameters.slice(1), signature2.returnType, minimum, signature2.isVariadic, names.slice(1), signature2.variadicType);
 }
 
+// ../compiler/src/checker/record-completion.ts
+function recordShapeOf(context, type) {
+  if (type.kind === "record") {
+    return type;
+  }
+  if (type.kind !== "named") {
+    return null;
+  }
+  const shape = context.assignability().resolveNominal?.(type.name) ?? null;
+  return shape === null ? null : { kind: "record", name: type.name, origin: null, members: shape.members };
+}
+function pendingKeys(context, source, target) {
+  if (source.kind !== "record" || source.isLiteral !== true) {
+    return null;
+  }
+  const shape = recordShapeOf(context, target);
+  if (shape === null) {
+    return null;
+  }
+  const missing2 = /* @__PURE__ */ new Map();
+  const options = context.assignability();
+  for (const [name, member] of shape.members) {
+    const written = source.members.get(name);
+    if (written === void 0) {
+      if (member.kind !== "optional") {
+        missing2.set(name, member);
+      }
+      continue;
+    }
+    if (!isAssignable(written, member, options)) {
+      return null;
+    }
+  }
+  for (const name of source.members.keys()) {
+    if (!shape.members.has(name)) {
+      return null;
+    }
+  }
+  return missing2.size === 0 ? null : missing2;
+}
+function deferRecordCompletion(context, target, source, declared, subject, position2) {
+  const path = pathOf2(target);
+  if (path === null) {
+    return false;
+  }
+  const missing2 = pendingKeys(context, source, declared);
+  if (missing2 === null) {
+    return false;
+  }
+  context.openRecordObligation({
+    path,
+    subject,
+    source,
+    target: declared,
+    missing: missing2,
+    discharged: 0,
+    depth: context.blockDepth,
+    line: position2.line,
+    position: position2
+  });
+  return true;
+}
+function reportIncompleteRecord(context, obligation, position2) {
+  if (obligation.discharged === 0) {
+    context.closeRecordObligation(obligation.path);
+    context.expectAssignable(obligation.source, obligation.target, obligation.position, obligation.subject);
+    return;
+  }
+  const keys = [...obligation.missing.keys()].map((key) => `"${key}"`);
+  const label2 = keys.length === 1 ? `Key ${keys[0]} is` : `Keys ${keys.join(", ")} are`;
+  const built = `The table built on line ${obligation.line} is used before it is complete.`;
+  const message = `${obligation.subject} expects "${typeToString(obligation.target)}". ${label2} never assigned. ${built}`;
+  context.report("check-incomplete-record", message, position2);
+  context.closeRecordObligation(obligation.path);
+}
+function dischargeRecordKey(context, target, valueType, position2) {
+  if (target.kind !== "member-expression") {
+    return false;
+  }
+  const path = pathOf2(target.object);
+  const obligation = path === null ? null : context.recordObligation(path);
+  if (obligation === null || obligation.depth !== context.blockDepth) {
+    return false;
+  }
+  const expected = obligation.missing.get(target.property);
+  if (expected === void 0) {
+    return false;
+  }
+  context.expectAssignable(valueType, expected, position2, `Key "${target.property}"`);
+  obligation.missing.delete(target.property);
+  obligation.discharged += 1;
+  if (obligation.missing.size === 0) {
+    context.closeRecordObligation(obligation.path);
+  }
+  return true;
+}
+function extendInferredRecord(context, target, valueType) {
+  if (target.kind !== "member-expression" || target.object.kind !== "identifier") {
+    return false;
+  }
+  const symbol = context.binder.lookup(target.object.name);
+  if (symbol === null || symbol.type.kind !== "record" || symbol.type.isInferred !== true || symbol.type.members.has(target.property)) {
+    return false;
+  }
+  const members = new Map(symbol.type.members);
+  members.set(target.property, widenInferred(valueType));
+  const extended = createObjectType(members);
+  symbol.type = extended.kind === "record" ? { ...extended, isInferred: true } : extended;
+  return true;
+}
+function escapesRecordObligation(context, expression) {
+  const path = pathOf2(expression);
+  const obligation = path === null ? null : context.recordObligation(path);
+  if (obligation !== null) {
+    reportIncompleteRecord(context, obligation, expression.position);
+  }
+}
+function settleRecordObligations(context, opened) {
+  for (const path of context.recordObligationPaths()) {
+    if (opened.has(path)) {
+      continue;
+    }
+    const obligation = context.recordObligation(path);
+    if (obligation === null) {
+      continue;
+    }
+    reportIncompleteRecord(context, obligation, obligation.position);
+  }
+}
+
 // ../compiler/src/checker/resource-exports.ts
 var RESOURCE_LOOKUP = "getResourceFromName";
 var EXPORTS_TABLE = "exports";
@@ -19516,9 +20070,6 @@ function isElementType(name) {
 
 // ../compiler/src/checker/oop-members.ts
 var OOP_HINT = 'Set "compiler = { oop = true }" in .luam.manifest to enable the MTA OOP API.';
-function scopeLabel2(environment) {
-  return environment === "shared" ? "shared" : `${environment}-only`;
-}
 function isMtaElementName(declarations, className) {
   if (!isElementType(className)) {
     return false;
@@ -19536,6 +20087,14 @@ function reportDisabled(context, className, name, position2) {
   const subject = `"${className}.${name}" is part of the MTA OOP API, which this project does not enable.`;
   context.report("check-oop-disabled", `${subject} Call "${member.procedural}" instead. ${OOP_HINT}`, position2);
 }
+function acceptsMember(context, className, name, member, position2) {
+  if (member.environment === void 0 || isAvailableIn(member.environment, context.environment)) {
+    return true;
+  }
+  const subject = `"${className}.${name}" wraps "${member.procedural}", which is ${scopeLabel(member.environment)}`;
+  reportEnvironment(context, "check-environment-api", `${subject} and ${unavailableTail(context.environment)}`, position2);
+  return context.environment === "shared";
+}
 function isMtaClassReference(context, className) {
   return isMtaClass(className) && context.binder.lookup(className) === null && context.declarations.lookupClass(className) === null && context.declarations.lookupInterface(className) === null;
 }
@@ -19551,12 +20110,7 @@ function resolveMtaStaticMember(context, className, name, position2) {
     reportDisabled(context, className, name, position2);
     return null;
   }
-  if (member.environment !== void 0 && !isAvailableIn(member.environment, context.environment)) {
-    const subject = `"${className}.${name}" wraps "${member.procedural}", which is ${scopeLabel2(member.environment)}`;
-    context.report("check-environment-api", `${subject} and is not available in a "${context.environment}" file.`, position2);
-    return null;
-  }
-  return member;
+  return acceptsMember(context, className, name, member, position2) ? member : null;
 }
 function resolveMtaConstructor(context, className, position2) {
   const constructor = mtaConstructor(className);
@@ -19571,9 +20125,11 @@ function resolveMtaConstructor(context, className, position2) {
     return null;
   }
   if (!isAvailableIn(constructor.environment, context.environment)) {
-    const subject = `"${className}(...)" is ${scopeLabel2(constructor.environment)}`;
-    context.report("check-environment-api", `${subject} and is not available in a "${context.environment}" file.`, position2);
-    return null;
+    const subject = `"${className}(...)" is ${scopeLabel(constructor.environment)}`;
+    reportEnvironment(context, "check-environment-api", `${subject} and ${unavailableTail(context.environment)}`, position2);
+    if (context.environment !== "shared") {
+      return null;
+    }
   }
   return constructor.type;
 }
@@ -19593,12 +20149,7 @@ function resolveMtaMember(context, className, name, position2) {
     reportUnknown(context, className, name, position2);
     return null;
   }
-  if (member.environment !== void 0 && !isAvailableIn(member.environment, context.environment)) {
-    const subject = `"${className}.${name}" wraps "${member.procedural}", which is ${scopeLabel2(member.environment)}`;
-    context.report("check-environment-api", `${subject} and is not available in a "${context.environment}" file.`, position2);
-    return null;
-  }
-  return member;
+  return acceptsMember(context, className, name, member, position2) ? member : null;
 }
 
 // ../compiler/src/checker/members.ts
@@ -19724,7 +20275,9 @@ function resolveNamedMember(context, receiver, expression) {
   if (contract === null) {
     return null;
   }
-  const members = new Map(context.declarations.collectMembers(name).map((member2) => [member2.name, member2]));
+  const substitutions = parameterSubstitutions(contract.typeParameters, receiver.typeArguments ?? []);
+  const collected = context.declarations.collectMembers(name).map((entry) => substitutions.size === 0 ? entry : { ...entry, type: substituteType(entry.type, substitutions) });
+  const members = new Map(collected.map((entry) => [entry.name, entry]));
   return checkInterfaceMember(context, name, members, expression);
 }
 function reportUnknownMethod(context, receiver, callee, method, position2) {
@@ -19892,6 +20445,39 @@ function checkUnary(context, operator, operand, expression) {
   return context.record(expression, NUMBER_TYPE);
 }
 
+// ../compiler/src/checker/shadowing.ts
+var HELPER_TARGETS = new Map(
+  NATIVE_EXTENSIONS.map((extension) => [
+    extension.target,
+    extension.style === "call" ? `${extension.receiver}.${extension.property}(...)` : `${extension.receiver}.${extension.property}`
+  ])
+);
+var SUPPRESSION = 'Rename the declaration, or record the new signature in a ".d.luam" file so later calls are checked against it.';
+function reportShadowedGlobal(context, name, position2) {
+  if (context.isDeclarationFile || !context.binder.isBuiltinReference(name)) {
+    return;
+  }
+  const message = `"${name}" is an API this environment declares. Later calls are still checked against the declared signature, not this one. ${SUPPRESSION}`;
+  context.warn("check-shadowed-api", message, position2);
+}
+function reportShadowedHelper(context, library, member, position2) {
+  if (context.isDeclarationFile || !isLibrary(library) || findLibraryMember(library, member) === null) {
+    return;
+  }
+  const target = `${library}.${member}`;
+  const rewrite = HELPER_TARGETS.get(target);
+  const lowered = rewrite === void 0 ? "" : ` The extension "${rewrite}" lowers to it.`;
+  const message = `"${target}" is part of the standard library this build models.${lowered} Later calls are still checked against the declared signature, not this one. ${SUPPRESSION}`;
+  context.warn("check-shadowed-helper", message, position2);
+}
+function reportImplicitGlobal(context, name, position2) {
+  if (context.isDeclarationFile || !context.noImplicitGlobals) {
+    return;
+  }
+  const message = `"${name}" is not declared anywhere this file can reach, so this assignment creates a global. Declare it with "local", annotate it as a global, or describe it in a ".d.luam" file.`;
+  context.warn("check-implicit-global", message, position2);
+}
+
 // ../compiler/src/checker/union-members.ts
 function isShapeOption(context, option) {
   if (option.kind === "record") {
@@ -20113,8 +20699,12 @@ function negatedFacts(context, condition) {
 // ../compiler/src/checker/control-flow.ts
 var ITERATOR_FUNCTIONS = /* @__PURE__ */ new Set(["pairs", "ipairs"]);
 function checkBlock(context, body) {
+  const opened = new Set(context.recordObligationPaths());
   context.binder.pushScope();
+  context.blockDepth += 1;
   checkStatements(context, body);
+  context.blockDepth -= 1;
+  settleRecordObligations(context, opened);
   const declared = context.binder.currentScopeNames();
   context.binder.popScope();
   for (const name of declared) {
@@ -20298,7 +20888,7 @@ function checkEventDeclaration(context, declaration) {
 }
 
 // ../compiler/src/checker/statements.ts
-var ORIGIN = { line: 0, column: 0, offset: 0 };
+var ORIGIN2 = { line: 0, column: 0, offset: 0 };
 function minimumArguments(context, parameters) {
   const index = parameters.findIndex((parameter) => {
     const type = context.resolveAnnotation(parameter.annotation);
@@ -20306,12 +20896,17 @@ function minimumArguments(context, parameters) {
   });
   return index === -1 ? parameters.length : index;
 }
-function buildFunctionType(context, parameters, returnAnnotation, contextual = null) {
+function buildFunctionType(context, parameters, returnAnnotation, contextual = null, isAsync = false) {
   const isVariadic = parameters.some((parameter) => parameter.isVararg);
   const named2 = parameters.filter((parameter) => !parameter.isVararg);
-  const types = named2.map((parameter, index) => parameter.annotation === null ? contextual?.parameters[index] ?? ANY_TYPE : context.resolveAnnotation(parameter.annotation));
+  const types = named2.map(
+    (parameter, index) => parameter.annotation === null ? contextual?.parameters[index] ?? ANY_TYPE : context.resolveValueAnnotation(parameter.annotation, "a parameter")
+  );
   const names = named2.map((parameter) => parameter.name);
-  return createFunction(types, context.resolveAnnotation(returnAnnotation), minimumArguments(context, parameters), isVariadic, names);
+  reportAsyncAnnotation(context, isAsync, returnAnnotation);
+  const declared = context.resolveAnnotation(asyncInnerAnnotation(isAsync, returnAnnotation));
+  const returnType = isAsync ? promiseOf(declared) : declared;
+  return createFunction(types, returnType, minimumArguments(context, parameters), isVariadic, names);
 }
 function applyTypeParameters(context, type, names, constraints) {
   if (names.length === 0) {
@@ -20337,14 +20932,16 @@ function reportMissingReturn(context, declared, position2) {
   const repair = declared.kind === "tuple" ? "Add a return on every path." : `Add a return on every path, or declare "${name}?".`;
   context.report("check-missing-return", `This function declares "${name}" but can end without returning a value. ${repair}`, position2);
 }
-function checkFunctionBody(context, parameters, returnAnnotation, body, signature2, selfType2, position2 = ORIGIN) {
+function checkFunctionBody(context, parameters, returnAnnotation, body, signature2, selfType2, position2 = ORIGIN2, frame = { isAsync: false, isExpression: false }) {
   forgetAssignedPaths(context, body);
   const entry = context.flowState;
+  const annotation = asyncInnerAnnotation(frame.isAsync, returnAnnotation);
   context.setFlow(cloneFlow(entry));
   context.binder.pushScope();
-  context.pushReturnType(returnAnnotation === null ? null : context.resolveAnnotation(returnAnnotation));
+  context.pushFunctionFrame(frame);
+  context.pushReturnType(annotation === null ? null : context.resolveAnnotation(annotation));
   if (selfType2 !== null) {
-    context.binder.declare({ name: "self", type: selfType2, isLocal: true, position: ORIGIN });
+    context.binder.declare({ name: "self", type: selfType2, isLocal: true, position: ORIGIN2 });
   }
   let parameterIndex = 0;
   for (const parameter of parameters) {
@@ -20354,15 +20951,20 @@ function checkFunctionBody(context, parameters, returnAnnotation, body, signatur
       parameterIndex += 1;
     }
   }
+  const opened = new Set(context.recordObligationPaths());
+  context.blockDepth += 1;
   checkStatements(context, body);
+  context.blockDepth -= 1;
+  settleRecordObligations(context, opened);
   const declared = context.currentReturnType();
   if (declared !== null && context.flowState.reachable && !toleratesFallthrough(declared)) {
     reportMissingReturn(context, declared, position2);
   }
   const inferred = context.popReturnType();
-  if (returnAnnotation === null) {
-    signature2.returnType = inferred;
+  if (annotation === null) {
+    signature2.returnType = frame.isAsync ? promiseOf(inferred) : inferred;
   }
+  context.popFunctionFrame();
   context.binder.popScope();
   context.setFlow(entry);
 }
@@ -20383,9 +20985,11 @@ function checkLocal(context, statement) {
       context.binder.declare({ name: declaration.name, type: inferred, isLocal: true, position: declaration.position, origin: "local" });
       return;
     }
-    const declared = context.resolveAnnotation(declaration.annotation);
-    if (value !== void 0) {
-      context.expectAssignable(valueType, declared, value.position, `Variable "${declaration.name}"`);
+    const declared = context.resolveValueAnnotation(declaration.annotation, "a local");
+    const subject = `Variable "${declaration.name}"`;
+    const deferred = value !== void 0 && deferRecordCompletion(context, { kind: "identifier", name: declaration.name, position: declaration.position }, valueType, declared, subject, value.position);
+    if (value !== void 0 && !deferred) {
+      context.expectAssignable(valueType, declared, value.position, subject);
     }
     context.binder.declare({ name: declaration.name, type: declared, isLocal: true, position: declaration.position, origin: "local" });
     if (value !== void 0) {
@@ -20404,6 +21008,13 @@ function checkCompoundOperand(context, operator, type, position2) {
     context.report("check-invalid-operand", `Operator "${operator}" cannot be applied to "${typeToString(type)}".`, position2);
   }
 }
+var DELETABLE_CONTAINERS = /* @__PURE__ */ new Set(["map", "array", "table"]);
+function deletesContainerKey(context, target, valueType) {
+  if (valueType.kind !== "nil" || target.kind !== "index-expression" && target.kind !== "member-expression") {
+    return false;
+  }
+  return DELETABLE_CONTAINERS.has(context.typeOf(target.object).kind);
+}
 function recordAssignedFact(context, path, valueType, declared) {
   if (path === null || valueType.kind === "any") {
     return;
@@ -20420,9 +21031,12 @@ function checkAssignment(context, statement) {
     if (assigned !== null) {
       context.forgetNarrowing(assigned);
     }
-    const targetType = checkExpression(context, target);
     const valueType = valueTypes[index] ?? NIL_TYPE;
     const value = valueAt(statement.values, valueTypes, index);
+    if (value !== void 0 && extendInferredRecord(context, target, valueType)) {
+      return;
+    }
+    const targetType = checkExpression(context, target);
     if (target.kind === "member-expression") {
       const object = context.typeOf(target.object);
       const frame = context.currentClassMethod();
@@ -20441,29 +21055,74 @@ function checkAssignment(context, statement) {
       return;
     }
     if (target.kind === "identifier" && context.binder.lookup(target.name) === null) {
+      reportImplicitGlobal(context, target.name, target.position);
       context.declareModuleGlobal({ name: target.name, type: valueType, isLocal: false, position: target.position });
       return;
     }
+    if (!context.insideFunction()) {
+      reportShadowedAssignment(context, target);
+    }
     const declared = target.kind === "identifier" ? context.binder.lookup(target.name)?.type ?? targetType : targetType;
+    if (deletesContainerKey(context, target, valueType)) {
+      return;
+    }
+    if (value !== void 0 && dischargeRecordKey(context, target, valueType, value.position)) {
+      return;
+    }
+    const path = pathOf2(target);
+    if (path !== null) {
+      context.closeRecordObligation(path);
+    }
+    if (value !== void 0 && deferRecordCompletion(context, target, valueType, declared, "Assignment", value.position)) {
+      return;
+    }
     if (value !== void 0) {
       context.expectAssignable(valueType, declared, value.position, "Assignment");
     }
     recordAssignedFact(context, pathOf2(target), valueType, declared);
   });
 }
+function rootIdentifier(expression) {
+  if (expression.kind === "identifier") {
+    return expression.name;
+  }
+  return expression.kind === "member-expression" || expression.kind === "index-expression" ? rootIdentifier(expression.object) : null;
+}
+function reportShadowedAssignment(context, target) {
+  if (target.kind !== "identifier") {
+    const root = rootIdentifier(target);
+    if (root !== null && context.binder.lookup(root) === null) {
+      reportImplicitGlobal(context, root, target.position);
+    }
+  }
+  if (target.kind === "identifier") {
+    reportShadowedGlobal(context, target.name, target.position);
+    return;
+  }
+  if (target.kind === "member-expression" && target.object.kind === "identifier") {
+    reportShadowedHelper(context, target.object.name, target.property, target.position);
+  }
+}
 function checkFunctionDeclaration(context, statement) {
-  const built = buildFunctionType(context, statement.parameters, statement.returnAnnotation);
+  const built = buildFunctionType(context, statement.parameters, statement.returnAnnotation, null, statement.isAsync);
   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) {
       context.binder.declare({ ...symbol, origin: "local" });
     } else {
+      reportShadowedGlobal(context, statement.name.name, statement.position);
       context.declareModuleGlobal(symbol);
     }
   }
+  if (!statement.isLocal && statement.name.kind !== "identifier") {
+    reportShadowedAssignment(context, statement.name);
+  }
   context.record(statement.name, type);
-  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null, statement.position);
+  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null, statement.position, {
+    isAsync: statement.isAsync,
+    isExpression: false
+  });
 }
 function checkReturn(context, statement) {
   const valueTypes = checkValueList(context, statement.values);
@@ -20514,7 +21173,34 @@ function checkDeclareStatement(context, statement) {
   }
   const type = context.resolveAnnotation(statement.annotation);
   context.declareModuleGlobal({ name: statement.name, type, isLocal: false, position: statement.position });
-  context.declarations.declareGlobal({ name: statement.name, type, position: statement.position });
+  context.declarations.declareGlobal({ name: statement.name, type, isDeclared: true, position: statement.position });
+}
+function checkGlobalStatement(context, statement) {
+  const declaration = statement.declaration;
+  const declared = declaration.annotation === null ? ANY_TYPE : context.resolveValueAnnotation(declaration.annotation, "a global");
+  const valueTypes = checkValueList(context, statement.values);
+  const value = valueAt(statement.values, valueTypes, 0);
+  if (context.insideFunction()) {
+    const message = `A type on global "${declaration.name}" is only valid at the top level of a file. Assign it without the annotation here.`;
+    context.report("check-global-annotation-scope", message, statement.position);
+    return;
+  }
+  const existing = context.declarations.lookupGlobal(declaration.name);
+  const contract = existing !== null && existing.isDeclared === true ? existing.type : declared;
+  if (existing !== null && existing.isDeclared !== true) {
+    context.report("check-duplicate-global", `Global "${declaration.name}" is already declared with a type.`, statement.position);
+  }
+  if (value !== void 0) {
+    context.expectAssignable(valueTypes[0] ?? NIL_TYPE, contract, value.position, `Global "${declaration.name}"`);
+  }
+  context.forgetNarrowing(declaration.name);
+  context.declareModuleGlobal({ name: declaration.name, type: contract, isLocal: false, position: declaration.position });
+  if (existing === null) {
+    context.declarations.declareGlobal({ name: declaration.name, type: contract, position: declaration.position });
+  }
+  if (value !== void 0) {
+    recordAssignedFact(context, declaration.name, valueTypes[0] ?? NIL_TYPE, contract);
+  }
 }
 function checkStatement(context, statement) {
   switch (statement.kind) {
@@ -20522,6 +21208,8 @@ function checkStatement(context, statement) {
       return checkLocal(context, statement);
     case "assignment-statement":
       return checkAssignment(context, statement);
+    case "global-statement":
+      return checkGlobalStatement(context, statement);
     case "call-statement":
       checkExpression(context, statement.expression);
       return;
@@ -20548,11 +21236,15 @@ function checkStatement(context, statement) {
     case "generic-for-statement":
       return checkGenericFor(context, statement);
     case "type-alias-statement": {
-      const resolved2 = context.resolveAnnotation(statement.annotation);
+      const resolved2 = context.resolveValueAnnotation(statement.annotation, "a type alias");
       const shape = statement.annotation.kind === "type-object" || statement.annotation.kind === "type-intersection";
       const named2 = shape ? renameRecord(resolved2, statement.name) : resolved2;
+      if (context.isAmbientAlias(statement.name)) {
+        context.report("check-duplicate-type", `Type "${statement.name}" is already defined.`, statement.position);
+      }
       context.noteTypeParameters(statement.typeParameters);
       context.binder.declareAlias(statement.name, named2, statement.typeParameters);
+      context.declarations.declareAlias({ name: statement.name, typeParameters: statement.typeParameters, type: named2, position: statement.position });
       return;
     }
     case "declare-statement":
@@ -20590,6 +21282,19 @@ function templateLiteralText(segments) {
   return segments.map((segment) => segment.kind === "text" ? segment.value : `\${${segment.value}}`).join("");
 }
 
+// ../compiler/src/checker/value-distribution.ts
+function distributeValueTypes(types) {
+  const distributed = [];
+  types.forEach((type, index) => {
+    if (index === types.length - 1) {
+      distributed.push(...valuesOf(type));
+      return;
+    }
+    distributed.push(firstValueOf(type));
+  });
+  return distributed;
+}
+
 // ../compiler/src/checker/expressions.ts
 var NAME_PATH_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/;
 var EXTENSION_RESULTS = {
@@ -20633,7 +21338,8 @@ function checkMember(context, expression) {
     checkExpression(context, expression.object);
     return context.record(expression, library);
   }
-  const objectType = checkExpression(context, expression.object);
+  const received = checkExpression(context, expression.object);
+  const objectType = received.kind === "optional" ? received.element : received;
   if (objectType.kind === "record") {
     return context.record(expression, resolveRecordMember(context, objectType, expression));
   }
@@ -20656,26 +21362,44 @@ function checkMember(context, expression) {
   }
   return context.record(expression, extension === null ? ANY_TYPE : EXTENSION_RESULTS[extension.result]);
 }
+function spreadsUnknownArity(args, argumentTypes) {
+  if (args.length === 0 || args.length !== argumentTypes.length) {
+    return false;
+  }
+  return args[args.length - 1]?.kind === "call-expression" && argumentTypes[argumentTypes.length - 1]?.kind === "any";
+}
+function resolveKeyedMember(context, objectType, expression) {
+  if (expression.index.kind !== "string-literal" || objectType.kind !== "record" && objectType.kind !== "named") {
+    return null;
+  }
+  const access = { kind: "member-expression", object: expression.object, property: expression.index.value, position: expression.index.position };
+  return objectType.kind === "record" ? resolveRecordMember(context, objectType, access) : resolveNamedMember(context, objectType, access);
+}
 function countArguments2(total) {
   return total === 1 ? "1 argument" : `${total} arguments`;
 }
 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 spreads = spreadsUnknownArity(args, argumentTypes);
+  const fixed = spreads ? argumentTypes.length - 1 : argumentTypes.length;
+  if (!spreads && 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 (!signature2.isVariadic && argumentTypes.length > signature2.parameters.length) {
+  if (!signature2.isVariadic && fixed > 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);
   }
   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 (argumentType === void 0 || argument === void 0) {
+      return;
     }
+    const optional = index >= signature2.minimumArguments && parameter.kind !== "optional";
+    const expected = optional ? createOptional(parameter) : parameter;
+    context.expectAssignable(argumentType, expected, argument.position, `Argument ${index + 1}`, parameter);
   });
   if (signature2.isVariadic && signature2.variadicType !== void 0) {
     for (let index = signature2.parameters.length; index < argumentTypes.length; index += 1) {
@@ -20688,6 +21412,20 @@ function checkSignature(context, args, declared, position2, owner = "This call",
   }
   return signature2.returnType;
 }
+function reportClassReceiver(context, name, method, position2) {
+  if (context.declarations.lookupStaticMember(name, method) !== null) {
+    const message2 = `Call the static member "${method}" as "${name}.${method}(...)". A class value has no "self" to pass.`;
+    context.report("check-static-receiver", message2, position2);
+    return;
+  }
+  if (context.declarations.lookupMember(name, method) === null) {
+    const message2 = `Call the static member "${method}" as "${name}.${method}(...)". A class value has no "self" to pass.`;
+    context.report("check-static-receiver", message2, position2);
+    return;
+  }
+  const message = `The receiver here is the class "${name}" itself, and "${method}" is one of its instance members. Create an instance \u2014 "local value = new ${name}()" \u2014 and call "value:${method}(...)", or read the member from a value of that class. Where the class and its single instance share one name, give the instance its own name.`;
+  context.report("check-class-receiver", message, position2);
+}
 function callOwner(expression) {
   const name = expression.method ?? (expression.callee.kind === "identifier" ? expression.callee.name : null);
   return name === null ? "This call" : `Function "${name}"`;
@@ -20737,6 +21475,9 @@ function checkMethodCall(context, expression, method, receiver) {
   return checkSignature(context, expression.args, member.type, expression.position);
 }
 function checkCall(context, expression) {
+  if (expression.method === null && expression.callee.kind === "identifier") {
+    reportSleepOutsideAsync(context, expression.callee.name, expression.position);
+  }
   const contracted = checkResourceCall(context, expression);
   if (contracted !== null) {
     return context.record(expression, contracted);
@@ -20759,9 +21500,7 @@ function checkCall(context, expression) {
     return context.record(expression, checkSignature(context, expression.args, constructor, expression.position));
   }
   if (expression.method !== null && expression.callee.kind === "identifier" && isUserClassReference(context, expression.callee.name)) {
-    const name = expression.callee.name;
-    const message = `Call the static member "${expression.method}" as "${name}.${expression.method}(...)". A class value has no "self" to pass.`;
-    context.report("check-static-receiver", message, expression.position);
+    reportClassReceiver(context, expression.callee.name, expression.method, expression.position);
     checkValueList(context, expression.args);
     return context.record(expression, ANY_TYPE);
   }
@@ -20840,6 +21579,8 @@ function checkMultiValueExpression(context, expression, expected = null) {
       const symbol = context.binder.lookup(expression.name);
       if (symbol === null) {
         checkGlobalReference(context, expression.name, expression.position);
+      } else {
+        checkSharedReference(context, expression.name, expression.position);
       }
       if (symbol === null || symbol.isLocal !== true) {
         context.noteGlobalReference(expression.name);
@@ -20855,6 +21596,10 @@ function checkMultiValueExpression(context, expression, expected = null) {
         context.expectAssignable(indexType, objectType.key, expression.index.position, "Key");
         return context.record(expression, objectType.value);
       }
+      const keyed = resolveKeyedMember(context, objectType, expression);
+      if (keyed !== null) {
+        return context.record(expression, keyed);
+      }
       return context.record(expression, objectType.kind === "array" ? objectType.element : ANY_TYPE);
     }
     case "call-expression":
@@ -20864,9 +21609,12 @@ function checkMultiValueExpression(context, expression, expected = null) {
     case "table-expression":
       return checkTable(context, expression);
     case "function-expression": {
-      const built = buildFunctionType(context, expression.parameters, expression.returnAnnotation, contextualFunction(expected));
+      const built = buildFunctionType(context, expression.parameters, expression.returnAnnotation, contextualFunction(expected), expression.isAsync);
       const type = applyTypeParameters(context, built, expression.typeParameters, expression.typeConstraints);
-      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, type, null, expression.position);
+      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, type, null, expression.position, {
+        isAsync: expression.isAsync,
+        isExpression: true
+      });
       return context.record(expression, type);
     }
     case "binary-expression": {
@@ -20876,6 +21624,8 @@ function checkMultiValueExpression(context, expression, expected = null) {
     }
     case "unary-expression":
       return checkUnary(context, expression.operator, checkExpression(context, expression.operand), expression);
+    case "await-expression":
+      return context.record(expression, awaitedType(context, checkExpression(context, expression.operand), expression));
     default:
       return context.record(expression, checkExpression(context, expression.expression, expected));
   }
@@ -20884,16 +21634,12 @@ function checkExpression(context, expression, expected = null) {
   return firstValueOf(checkMultiValueExpression(context, expression, expected));
 }
 function checkValueList(context, values, expected = []) {
-  const types = [];
-  values.forEach((value, index) => {
+  const types = values.map((value, index) => {
     const type = checkMultiValueExpression(context, value, expected[index] ?? null);
-    if (index === values.length - 1) {
-      types.push(...valuesOf(type));
-      return;
-    }
-    types.push(firstValueOf(type));
+    escapesRecordObligation(context, value);
+    return type;
   });
-  return types;
+  return distributeValueTypes(types);
 }
 
 // ../compiler/src/checker/classes.ts
@@ -20902,7 +21648,7 @@ function fieldType(context, member) {
   if (member.annotation === null) {
     return valueType === null ? ANY_TYPE : widenInferred(valueType);
   }
-  const declared = context.resolveAnnotation(member.annotation);
+  const declared = context.resolveValueAnnotation(member.annotation, "a field");
   if (valueType !== null && member.value !== null) {
     context.expectAssignable(valueType, declared, member.value.position, `Field "${member.name}"`);
   }
@@ -20955,7 +21701,12 @@ 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) : applyTypeParameters(context, buildFunctionType(context, member.parameters, member.returnAnnotation), member.typeParameters, member.typeConstraints);
+    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, null, member.isAsync),
+      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);
@@ -20996,6 +21747,7 @@ function declareBuilder(context, info, statement) {
     superClass: null,
     superArguments: [],
     interfaces: [],
+    interfaceArguments: [],
     members,
     statics: /* @__PURE__ */ new Map(),
     position: statement.position
@@ -21014,17 +21766,19 @@ function checkMethodBody(context, info, member) {
   if (signature2?.kind !== "function") {
     return;
   }
+  const frame = { isAsync: member.isAsync, isExpression: false };
   if (member.isStatic) {
-    checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature2, null, member.position);
+    checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature2, null, member.position, frame);
     return;
   }
   context.pushClassMethod({ className: info.name, methodName: member.name });
-  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature2, selfType(info), member.position);
+  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature2, selfType(info), member.position, frame);
   context.popClassMethod();
 }
 function assignSuperClass(context, info, statement) {
-  info.superClass = resolveSuperClass(context, statement);
-  info.hasUnresolvedParent = statement.superClass !== null && info.superClass === null;
+  const resolved2 = resolveSuperClass(context, statement);
+  info.superClass = resolved2 ?? statement.superClass;
+  info.hasUnresolvedParent = statement.superClass !== null && resolved2 === null;
 }
 function resolveSuperClass(context, statement) {
   if (statement.superClass === null) {
@@ -21066,6 +21820,7 @@ function declareClassInfo(context, statement) {
     superClass: null,
     superArguments: [],
     interfaces: statement.interfaces,
+    interfaceArguments: statement.interfaceArguments.map((args) => args.map((argument) => context.resolveAnnotation(argument))),
     members: /* @__PURE__ */ new Map(),
     statics: /* @__PURE__ */ new Map(),
     position: statement.position
@@ -21100,10 +21855,12 @@ function checkClassDeclaration(context, statement) {
   }
 }
 function checkInterfaceDeclaration(context, statement) {
-  if (context.declarations.lookupInterface(statement.name) !== null) {
+  const existing = context.declarations.lookupInterface(statement.name);
+  if (existing !== null && existing.isBuiltin !== true) {
     context.report("check-duplicate-interface", `Interface "${statement.name}" is already defined.`, statement.position);
     return;
   }
+  context.noteTypeParameters(statement.typeParameters);
   const members = /* @__PURE__ */ new Map();
   for (const name of new Set(statement.superInterfaces)) {
     const parent = context.declarations.lookupInterface(name);
@@ -21120,7 +21877,7 @@ function checkInterfaceDeclaration(context, statement) {
     context.report("check-duplicate-interface-parent", `Interface "${statement.name}" extends the same interface more than once.`, statement.position);
   }
   for (const member of statement.members) {
-    const type = member.kind === "interface-field" ? context.resolveAnnotation(member.annotation) : buildFunctionType(context, member.parameters, member.returnAnnotation);
+    const type = member.kind === "interface-field" ? context.resolveValueAnnotation(member.annotation, "a member") : buildFunctionType(context, member.parameters, member.returnAnnotation);
     const info = { name: member.name, type, isMethod: member.kind === "interface-method", position: member.position };
     if (members.has(member.name)) {
       context.report("check-duplicate-interface-member", `Interface "${statement.name}" declares member "${member.name}" more than once.`, member.position);
@@ -21131,16 +21888,18 @@ function checkInterfaceDeclaration(context, statement) {
   const inherited = /* @__PURE__ */ new Map();
   for (const parent of statement.superInterfaces) {
     for (const member of context.declarations.collectInterfaceContract(parent)) {
-      const existing = members.get(member.name) ?? inherited.get(member.name);
-      if (existing !== void 0 && (existing.isMethod !== member.isMethod || typeToString(existing.type) !== typeToString(member.type))) {
+      const existing2 = members.get(member.name) ?? inherited.get(member.name);
+      if (existing2 !== void 0 && (existing2.isMethod !== member.isMethod || typeToString(existing2.type) !== typeToString(member.type))) {
         context.report("check-conflicting-interface-member", `Interface "${statement.name}" inherits conflicting declarations of "${member.name}".`, statement.position);
-      } else if (existing === void 0) {
+      } else if (existing2 === void 0) {
         inherited.set(member.name, member);
       }
     }
   }
   context.declarations.declareInterface({
     name: statement.name,
+    typeParameters: statement.typeParameters,
+    typeConstraints: statement.typeConstraints.map((constraint) => constraint === null ? null : context.resolveAnnotation(constraint)),
     superInterfaces: statement.superInterfaces,
     members,
     position: statement.position
@@ -21263,12 +22022,14 @@ function check(program2, mode, environment = DEFAULT_ENVIRONMENT, options = {})
   const ambient = options.ambient ?? EMPTY_AMBIENT;
   const project = options.project ?? EMPTY_PROJECT_DECLARATIONS;
   const context = new CheckContext(mode, environment, ambient, project, options.oop === true);
+  context.noImplicitGlobals = options.noImplicitGlobals === true;
   context.isDeclarationFile = options.isDeclarationFile === true;
   context.contracts = options.contracts ?? [];
   const structure = context.isDeclarationFile ? checkDeclarationFile(program2.body) : checkJumps(program2.body);
   const directives = collectDirectives(program2.body, { isDeclarationFile: context.isDeclarationFile });
   predeclareModule(context, program2.body);
   checkStatements(context, program2.body);
+  settleRecordObligations(context, /* @__PURE__ */ new Set());
   reportUnknownTypes(context);
   reportUnusedSymbols(context, options.noUnusedLocals === true, options.noUnusedParameters === true);
   const external = externalReferences(context);
@@ -21517,7 +22278,24 @@ function emitString(value) {
 function emitParameters(parameters) {
   return parameters.map((parameter) => parameter.isVararg ? "..." : parameter.name).join(", ");
 }
-function emitFunctionBody(state, parameters, body, header) {
+function emitAsyncFunctionBody(state, parameters, body, header, receiver) {
+  requireHelper(state, "promise");
+  const declared = emitParameters(parameters);
+  const forwarded = (receiver === null ? [declared] : [receiver, declared]).filter((part) => part.length > 0).join(", ");
+  const previous = state.loopWrap;
+  state.indent += 1;
+  state.loopWrap = false;
+  const lines = emitBlock(state, body);
+  state.loopWrap = previous;
+  state.indent -= 1;
+  const signature2 = `${header}(${declared}) return Promise.spawn(function(${forwarded})`;
+  const closing = indentLine(state, `end${forwarded.length === 0 ? "" : `, ${forwarded}`}) end`);
+  return [signature2, ...lines, closing].join("\n");
+}
+function emitFunctionBody(state, parameters, body, header, isAsync = false, receiver = null) {
+  if (isAsync) {
+    return emitAsyncFunctionBody(state, parameters, body, header, receiver);
+  }
   const previous = state.loopWrap;
   state.indent += 1;
   state.loopWrap = false;
@@ -21627,7 +22405,7 @@ function emitExpression(state, expression, limit = 0) {
     case "table-expression":
       return emitTable(state, expression);
     case "function-expression":
-      return emitFunctionBody(state, expression.parameters, expression.body, "function");
+      return emitFunctionBody(state, expression.parameters, expression.body, "function", expression.isAsync);
     case "binary-expression":
       return emitBinary(state, expression, limit);
     case "unary-expression": {
@@ -21635,19 +22413,26 @@ function emitExpression(state, expression, limit = 0) {
       const text = expression.operator === "not" ? `not ${operand}` : `${expression.operator}${operand}`;
       return UNARY_PRECEDENCE < limit ? `(${text})` : text;
     }
+    case "await-expression":
+      requireHelper(state, "promise");
+      return `Promise.await(${emitExpression(state, expression.operand)})`;
     default:
       return `(${emitExpression(state, expression.expression)})`;
   }
 }
 
 // ../compiler/src/emitter/classes.ts
+var BARE_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function emitMemberKey(name) {
+  return BARE_KEY.test(name) ? name : `[${emitString(name)}]`;
+}
 function emitMethod(state, className, member) {
   const self = { name: "self", annotation: null, isVararg: false, position: member.position };
   if (member.generated !== void 0) {
     return emitGeneratedMethod(state, className, member);
   }
   const parameters = member.isStatic ? member.parameters : [self, ...member.parameters];
-  return withSymbol(state, `${className}${member.isStatic ? "." : ":"}${member.name}`, () => emitFunctionBody(state, parameters, member.body, `${member.name} = function`));
+  return withSymbol(state, `${className}${member.isStatic ? "." : ":"}${member.name}`, () => emitFunctionBody(state, parameters, member.body, `${emitMemberKey(member.name)} = function`, member.isAsync));
 }
 function emitGeneratedMethod(state, className, member) {
   const fields = member.generated?.fields ?? [];
@@ -21733,7 +22518,7 @@ function emitMembers(state, statement) {
       continue;
     }
     const value = member.value === null ? "nil" : emitExpression(state, member.value);
-    entries3.push(indentLine(state, `${markSource(state, member.position.line, statement.name)}${member.name} = ${value}`));
+    entries3.push(indentLine(state, `${markSource(state, member.position.line, statement.name)}${emitMemberKey(member.name)} = ${value}`));
   }
   for (const generated of state.generatedMembers.get(statement) ?? []) {
     entries3.push(indentLine(state, `${markSource(state, generated.position.line, `${statement.name}:${generated.name}`)}${emitMethod(state, statement.name, generated)}`));
@@ -21887,7 +22672,7 @@ function emitFunctionDeclaration(state, statement) {
   const prefix = statement.isLocal ? "local function " : "function ";
   const name = emitFunctionName(state, statement);
   const header = `${prefix}${name}`;
-  return withSymbol(state, name, () => emitFunctionBody(state, statement.parameters, statement.body, header));
+  return withSymbol(state, name, () => emitFunctionBody(state, statement.parameters, statement.body, header, statement.isAsync, statement.isMethod ? "self" : null));
 }
 function emitNested2(state, body) {
   state.indent += 1;
@@ -21926,6 +22711,8 @@ function emitStatement(state, statement) {
       return emitLocal(state, statement);
     case "assignment-statement":
       return emitAssignment(state, statement);
+    case "global-statement":
+      return `${statement.declaration.name} = ${statement.values.map((value) => emitExpression(state, value)).join(", ")}`;
     case "call-statement":
       return emitExpression(state, statement.expression);
     case "function-declaration":
@@ -22099,6 +22886,7 @@ function fromExpression(expression, blocks) {
       fromExpression(expression.right, blocks);
       return;
     case "unary-expression":
+    case "await-expression":
       fromExpression(expression.operand, blocks);
       return;
     case "group-expression":
@@ -22133,6 +22921,9 @@ function nestedBlocks(statement) {
     case "assignment-statement":
       fromExpressions([...statement.targets, ...statement.values], blocks);
       break;
+    case "global-statement":
+      fromExpressions(statement.values, blocks);
+      break;
     case "call-statement":
       fromExpression(statement.expression, blocks);
       break;
@@ -22211,6 +23002,16 @@ function reindent(code, indent) {
   }
   return code.split("\n").map((line2, index) => index === 0 || line2.length === 0 ? line2 : `${indent}${line2}`).join("\n");
 }
+var CLOSING_LINE = /^\s*(?:end|\})/;
+function padAboveClosing(replacement, missing2) {
+  const lines = replacement.split("\n");
+  const closing = lines[lines.length - 1] ?? "";
+  const blanks = Array.from({ length: missing2 }, () => "");
+  if (lines.length < 2 || !CLOSING_LINE.test(closing)) {
+    return [replacement, ...blanks].join("\n");
+  }
+  return [...lines.slice(0, -1), ...blanks, closing].join("\n");
+}
 function erasedEnd(source, span) {
   const trailing = TRAILING_SEMICOLON.exec(source.slice(span.end));
   return trailing === null ? span.end : span.end + trailing[0].length;
@@ -22233,7 +23034,7 @@ function canonicalEdit(input, statement, span) {
   if (missing2 < 0 && input.development) {
     return null;
   }
-  const padded = missing2 > 0 && source.slice(end).trim().length > 0 ? `${replacement}${"\n".repeat(missing2)}` : replacement;
+  const padded = missing2 > 0 && source.slice(end).trim().length > 0 ? padAboveClosing(replacement, missing2) : replacement;
   return { start: span.start, end, replacement: padded, lines: emitted2.lines };
 }
 
@@ -22262,7 +23063,10 @@ function isPreservableExpression(expression, types, statics = NO_STATIC_ACCESS)
   switch (expression.kind) {
     case "template-literal":
     case "new-expression":
+    case "await-expression":
       return false;
+    case "function-expression":
+      return !expression.isAsync;
     case "member-expression":
       return !statics.has(expression) && resolvePropertyExtension(types.get(expression.object) ?? null, expression.property) === null && isPreservableExpression(expression.object, types, statics);
     case "index-expression":
@@ -22311,11 +23115,12 @@ function isPreservableStatement(statement, types, statics = NO_STATIC_ACCESS) {
       return isPreservableExpression(statement.start, types, statics) && isPreservableExpression(statement.limit, types, statics) && (statement.step === null || isPreservableExpression(statement.step, types, statics));
     case "generic-for-statement":
       return every(statement.iterators, types, statics);
+    case "function-declaration":
+      return !statement.isAsync;
     case "break-statement":
     case "declare-statement":
     case "do-statement":
     case "event-declaration":
-    case "function-declaration":
     case "interface-declaration":
     case "type-alias-statement":
       return true;
@@ -22491,6 +23296,7 @@ function children(expression) {
     case "binary-expression":
       return [expression.left, expression.right];
     case "unary-expression":
+    case "await-expression":
       return [expression.operand];
     case "group-expression":
       return [expression.expression];
@@ -22543,6 +23349,22 @@ function statementExpressions3(statement) {
       return null;
   }
 }
+function constructionEdit(input, expression, span) {
+  const start = input.source.indexOf(expression.className, span.start);
+  if (start === -1 || start >= span.end) {
+    return null;
+  }
+  const isLibrary2 = input.types.get(expression)?.kind === "record";
+  if (isLibrary2) {
+    return { start: span.start, end: start + expression.className.length, replacement: `${expression.className}.new` };
+  }
+  const spacing = /^[ \t]*/.exec(input.source.slice(start + expression.className.length))?.[0] ?? "";
+  return {
+    start: span.start,
+    end: start + expression.className.length + spacing.length,
+    replacement: `new ${emitString(expression.className)} `
+  };
+}
 function expressionEdits(input, statement) {
   const slots = input.development ? statementExpressions3(statement) : null;
   if (slots === null) {
@@ -22555,7 +23377,18 @@ function expressionEdits(input, statement) {
   const edits = [];
   for (const expression of found) {
     const span = input.spans.get(expression);
-    if (span === void 0 || holdsFunction(expression)) {
+    if (span === void 0) {
+      return null;
+    }
+    if (expression.kind === "new-expression") {
+      const edit = constructionEdit(input, expression, span);
+      if (edit === null) {
+        return null;
+      }
+      edits.push(edit);
+      continue;
+    }
+    if (holdsFunction(expression)) {
       return null;
     }
     const state = createEmitState(input.types, input.references, input.generatedMembers, input.staticAccess);
@@ -22824,6 +23657,7 @@ function compile(source, options = {}) {
     isDeclarationFile,
     oop: settings.oop,
     noUnusedLocals: settings.noUnusedLocals,
+    noImplicitGlobals: settings.noImplicitGlobals,
     noUnusedParameters: settings.noUnusedParameters
   });
   const diagnostics = sortDiagnostics([...parsed.diagnostics, ...resolved2.diagnostics, ...checked.diagnostics]);
@@ -23067,11 +23901,12 @@ function createDependencyGraph(nodes) {
 
 // ../compiler/src/project/ambient-scope.ts
 function optionsKey(options) {
-  return `${options.strict ? "strict" : ""}|${options.oop ? "oop" : ""}|${options.noUnusedLocals ? "nul" : ""}|${options.noUnusedParameters ? "nup" : ""}`;
+  const flags = [options.strict ? "strict" : "", options.oop ? "oop" : "", options.noUnusedLocals ? "nul" : "", options.noUnusedParameters ? "nup" : ""];
+  return `${flags.join("|")}|${options.noImplicitGlobals ? "nig" : ""}`;
 }
 function declaresNothing(declarations) {
-  const { classes, interfaces, enums, globals, events } = declarations;
-  return classes.length === 0 && interfaces.length === 0 && enums.length === 0 && globals.length === 0 && events.length === 0;
+  const { classes, interfaces, enums, aliases, globals, events } = declarations;
+  return classes.length === 0 && interfaces.length === 0 && enums.length === 0 && aliases.length === 0 && globals.length === 0 && events.length === 0;
 }
 function sharedEnums(collected) {
   const declared = new Set(collected.flatMap((entry) => entry.declarations.enums.map((enumeration) => enumeration.name)));