@thigasdevelopment/luam 1.0.0 → 1.0.2

package/luam.mjs

@@ -3609,6 +3609,8 @@ var LUA_KEYWORDS = /* @__PURE__ */ new Set([
   "while"
 ]);
 var LUAM_KEYWORDS = /* @__PURE__ */ new Set([
+  "async",
+  "await",
   "class",
   "constructor",
   "continue",
@@ -4279,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);
@@ -4288,6 +4303,7 @@ function parseFunctionExpression(stream) {
   stream.expect("keyword", "end");
   return {
     kind: "function-expression",
+    isAsync,
     typeParameters: typeParameters.names,
     typeConstraints: typeParameters.constraints,
     parameters,
@@ -4309,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);
@@ -4320,6 +4336,7 @@ function parseFunctionDeclaration(stream, isLocal, isExported = false, isHttpExp
   return {
     kind: "function-declaration",
     name,
+    isAsync,
     isLocal,
     isExported,
     isHttpExport,
@@ -4374,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 };
@@ -4432,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 };
@@ -4524,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) {
@@ -4715,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,
@@ -4733,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,
@@ -4772,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();
@@ -4787,14 +4822,15 @@ function parseStaticModifier(stream) {
 }
 function parseClassMember(stream) {
   const decorators = parseDecorators(stream);
-  const isStatic = parseStaticModifier(stream);
+  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", "=") ? parseFieldValue(stream) : null;
@@ -5075,6 +5111,10 @@ function parseGlobalDeclaration(stream) {
   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;
@@ -5106,6 +5146,10 @@ function parseKeywordStatement(stream, value) {
     if (stream.check("keyword", "function")) {
       return parseFunctionDeclaration(stream, true);
     }
+    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);
   }
@@ -5148,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);
   }
@@ -5794,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 = {
@@ -7099,7 +7154,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "1.0.0" : "0.0.0-dev";
+var VERSION = true ? "1.0.2" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -8987,7 +9042,7 @@ var EMPTY_AMBIENT = { classes: [], interfaces: [], enums: [], aliases: [], globa
 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(),
@@ -9155,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()];
@@ -9486,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) },
@@ -9494,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) },
@@ -9503,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) }])
@@ -14591,6 +14740,7 @@ var CheckContext = class {
   isDeclarationFile = false;
   returnStack = [];
   methodStack = [];
+  functionStack = [];
   projectEnvironments = /* @__PURE__ */ new Map();
   predeclared = /* @__PURE__ */ new Map();
   ambientClasses = /* @__PURE__ */ new Set();
@@ -14606,6 +14756,7 @@ var CheckContext = class {
     this.environment = environment;
     this.mtaClasses = oop ? mtaClassRegistry() : null;
     this.binder.useBuiltins(builtinSymbols(environment));
+    declarePromiseType(this.declarations);
     this.declareProject(project);
     this.declareAmbient(ambient);
   }
@@ -14779,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;
@@ -15040,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];
@@ -15615,6 +15779,7 @@ function accessorMethod(field2, decorator, name) {
   return {
     kind: "class-method",
     name,
+    isAsync: false,
     isConstructor: false,
     isSynthetic: true,
     isStatic: false,
@@ -15628,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 };
@@ -15663,6 +15828,7 @@ function staticMethod(statement, name, returnAnnotation, kind, descriptor) {
   return {
     kind: "class-method",
     name,
+    isAsync: false,
     isConstructor: false,
     isSynthetic: true,
     isStatic: true,
@@ -15818,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];
@@ -20721,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);
@@ -20729,14 +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.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) {
@@ -20762,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) {
@@ -20789,9 +20961,10 @@ function checkFunctionBody(context, parameters, returnAnnotation, body, signatur
     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);
 }
@@ -20931,7 +21104,7 @@ function reportShadowedAssignment(context, target) {
   }
 }
 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 };
@@ -20946,7 +21119,10 @@ function checkFunctionDeclaration(context, statement) {
     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);
@@ -21299,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);
@@ -21430,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": {
@@ -21442,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));
   }
@@ -21517,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);
@@ -21577,12 +21766,13 @@ 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) {
@@ -21665,7 +21855,8 @@ 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;
   }
@@ -21697,10 +21888,10 @@ 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);
       }
     }
@@ -22087,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;
@@ -22197,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": {
@@ -22205,6 +22413,9 @@ 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)})`;
   }
@@ -22221,7 +22432,7 @@ function emitMethod(state, className, member) {
     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, `${emitMemberKey(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 ?? [];
@@ -22461,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;
@@ -22675,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":
@@ -22790,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;
@@ -22812,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 };
 }
 
@@ -22841,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":
@@ -22890,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;
@@ -23070,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];
@@ -23122,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) {
@@ -23134,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);