@thigasdevelopment/luam 0.19.12 → 1.0.0

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 = {
@@ -3838,7 +3839,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 +3904,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 +4049,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 +4149,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 +4263,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) {
@@ -4406,6 +4456,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 +4496,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", "]");
@@ -4622,7 +4681,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;
@@ -4692,6 +4755,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 === ",");
@@ -4717,7 +4788,7 @@ function parseStaticModifier(stream) {
 function parseClassMember(stream) {
   const decorators = parseDecorators(stream);
   const isStatic = parseStaticModifier(stream);
-  const token = stream.expectName();
+  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);
@@ -4726,7 +4797,7 @@ function parseClassMember(stream) {
     return parseClassMethod(stream, token, decorators, isStatic);
   }
   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 +4810,7 @@ function parseClassModifiers(stream, declaration) {
     }
     do {
       declaration.interfaces.push(stream.expect("identifier").value);
+      declaration.interfaceArguments.push(parseTypeArguments(stream));
     } while (stream.match("punctuation", ","));
   }
 }
@@ -4754,6 +4826,7 @@ function parseClassDeclaration(stream, decorators) {
     superClass: null,
     superClassArguments: [],
     interfaces: [],
+    interfaceArguments: [],
     members: [],
     decorators,
     position: position2
@@ -4780,7 +4853,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 +4869,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 +4892,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 +4961,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 +5055,30 @@ 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) {
+  const declaration = parseGlobalDeclaration(stream);
+  if (declaration !== null) {
+    return declaration;
+  }
   const start = stream.current();
   const position2 = start.position;
   const targets = [parseSuffixed(stream)];
@@ -5001,7 +5106,8 @@ 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);
+    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);
@@ -5266,10 +5372,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 +5545,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") {
@@ -5741,6 +5858,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 +6922,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 +7099,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.0" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -7042,7 +7163,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 +8983,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(),
     enums: registry.allEnums().filter((info) => info.isLocal !== true),
+    aliases: registry.allAliases(),
     globals: registry.allGlobals(),
     events: registry.allEvents()
   };
@@ -8885,6 +9007,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 +9026,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 +9101,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 = {
@@ -9195,6 +9322,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 +9352,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 +9445,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;
@@ -12233,10 +12376,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 +12391,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 +14196,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 +14240,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 +14389,7 @@ function buildRegistry() {
       superClass: declaration.parent,
       superArguments: [],
       interfaces: [],
+      interfaceArguments: [],
       members,
       statics: /* @__PURE__ */ new Map(),
       position: MTA_POSITION
@@ -14435,6 +14596,11 @@ var CheckContext = class {
   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;
@@ -14510,6 +14676,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);
@@ -14679,19 +14863,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 +14905,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 +14932,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 +14991,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"',
@@ -14848,6 +15051,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 +15199,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) {
@@ -15615,6 +15829,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 +15887,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 +19301,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 +19344,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 +19382,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 +19564,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 +19903,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 +19920,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 +19943,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 +19958,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 +19982,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 +20108,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 +20278,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 +20532,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) {
@@ -20309,7 +20732,9 @@ function minimumArguments(context, parameters) {
 function buildFunctionType(context, parameters, returnAnnotation, contextual = null) {
   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);
 }
@@ -20354,7 +20779,11 @@ 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);
@@ -20383,9 +20812,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 +20835,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 +20858,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,16 +20882,54 @@ 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 type = applyTypeParameters(context, built, statement.typeParameters, statement.typeConstraints);
@@ -20459,9 +20938,13 @@ function checkFunctionDeclaration(context, statement) {
     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);
 }
@@ -20514,7 +20997,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 +21032,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 +21060,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 +21106,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 +21162,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 +21186,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 +21236,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}"`;
@@ -20759,9 +21321,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 +21400,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 +21417,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":
@@ -20884,16 +21450,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 +21464,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}"`);
   }
@@ -20996,6 +21558,7 @@ function declareBuilder(context, info, statement) {
     superClass: null,
     superArguments: [],
     interfaces: [],
+    interfaceArguments: [],
     members,
     statics: /* @__PURE__ */ new Map(),
     position: statement.position
@@ -21023,8 +21586,9 @@ function checkMethodBody(context, info, member) {
   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 +21630,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
@@ -21104,6 +21669,7 @@ function checkInterfaceDeclaration(context, statement) {
     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 +21686,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);
@@ -21141,6 +21707,8 @@ function checkInterfaceDeclaration(context, statement) {
   }
   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 +21831,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);
@@ -21641,13 +22211,17 @@ function emitExpression(state, expression, limit = 0) {
 }
 
 // ../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`));
 }
 function emitGeneratedMethod(state, className, member) {
   const fields = member.generated?.fields ?? [];
@@ -21733,7 +22307,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)}`));
@@ -21926,6 +22500,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":
@@ -22133,6 +22709,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;
@@ -22824,6 +23403,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 +23647,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)));