@thigasdevelopment/luam 0.2.1 → 0.4.1

package/luam.mjs

@@ -190,7 +190,7 @@ function parseArguments(argv) {
       continue;
     }
     if (parsed.command !== null) {
-      if (parsed.command === "trace" && parsed.operand === null) {
+      if ((parsed.command === "init" || parsed.command === "trace") && parsed.operand === null) {
         parsed.operand = token;
         continue;
       }
@@ -212,12 +212,13 @@ var EXIT_DIAGNOSTICS = 1;
 var EXIT_USAGE = 2;
 
 // src/cli/usage.ts
-var VERSION = true ? "0.2.1" : "0.0.0-dev";
+var VERSION = true ? "0.4.1" : "0.0.0-dev";
 var USAGE = [
   "luam \u2014 the Luam compiler for Multi Theft Auto resources.",
   "",
   "Usage:",
   "    luam <command> [options]",
+  "    luam init [path] [options]",
   "",
   "Commands:",
   "    build     Compile the project and write the resource to the output directory.",
@@ -225,16 +226,16 @@ var USAGE = [
   "    dev       Build, sync, restart, watch, and stream resource development logs.",
   "    doctor    Check the CLI, supported editors, and the Luam extension.",
   "    ensure    Build, sync the resource into the MTA server, and restart it.",
-  "    init      Scaffold a new resource project with the framework and example handlers.",
+  "    init      Interactively scaffold a new resource project.",
   "    setup     Detect supported editors and install the Luam extension with consent.",
   "    trace     Resolve generated Lua positions back to Luam source positions.",
   "",
   "Options:",
   "    --cwd <path>       Project directory that contains luam.json. Defaults to the current directory.",
   "    --config <path>    Configuration file to load instead of luam.json.",
-  "    --name <name>      Resource name for init. Defaults to the project directory name.",
+  "    --name <name>      Resource name for init. Defaults to the destination directory name.",
   "    --force            Let init overwrite files that already exist.",
-  "    -y, --yes          Install the extension in every detected editor without prompting.",
+  "    -y, --yes          Accept init defaults or install every detected editor without prompting.",
   "    --watch            Keep ensure or dev running and rebuild on source changes.",
   "    --no-watch         Run ensure or dev once and exit.",
   "    --bundle           Build or ensure with bundled output.",
@@ -916,6 +917,15 @@ function createNamed(name) {
 function createRecord(name, members, origin = null) {
   return { kind: "record", name, origin, members };
 }
+function renameRecord(type, name) {
+  return type.kind === "record" ? createRecord(name, type.members, type.origin) : type;
+}
+function createObjectType(members) {
+  const keys = [...members].map(
+    ([name, member]) => member.kind === "optional" ? `${name}?: ${typeToString(member.element)}` : `${name}: ${typeToString(member)}`
+  );
+  return createRecord(keys.length === 0 ? "{}" : `{ ${keys.join(", ")} }`, members);
+}
 function createFunction(parameters, returnType, minimumArguments2, isVariadic = false) {
   return { kind: "function", parameters, returnType, minimumArguments: minimumArguments2 ?? parameters.length, isVariadic };
 }
@@ -1022,6 +1032,21 @@ function isFunctionAssignable(source, target, options) {
   }
   return target.returnType.kind === "void" || isAssignable(source.returnType, target.returnType, options);
 }
+function isRecordAssignable(source, target, options) {
+  for (const [name, member] of target.members) {
+    const value = source.members.get(name);
+    if (value === void 0) {
+      if (member.kind !== "optional") {
+        return false;
+      }
+      continue;
+    }
+    if (!isAssignable(value, member, options)) {
+      return false;
+    }
+  }
+  return true;
+}
 function isAssignable(source, target, options = { allowNil: false }) {
   if (source.kind === "any" || target.kind === "any" || target.kind === "unknown") {
     return true;
@@ -1053,6 +1078,9 @@ function isAssignable(source, target, options = { allowNil: false }) {
   if (target.kind === "table") {
     return isTableLike(source) || source.kind === "record";
   }
+  if (target.kind === "record") {
+    return source.kind === "record" ? isRecordAssignable(source, target, options) : source.kind === "table";
+  }
   if (target.kind === "array") {
     return source.kind === "table" || source.kind === "array" && isAssignable(source.element, target.element, options);
   }
@@ -1137,8 +1165,8 @@ var Binder = class {
   isDeclaredInCurrentScope(name) {
     return this.scopes[this.scopes.length - 1]?.has(name) ?? false;
   }
-  declareAlias(name, type) {
-    this.aliases.set(name, type);
+  declareAlias(name, type, parameters = []) {
+    this.aliases.set(name, { type, parameters });
   }
   lookupAlias(name) {
     return this.aliases.get(name) ?? null;
@@ -4831,6 +4859,14 @@ var DeclarationRegistry = class {
   lookupInterface(name) {
     return this.interfaces.get(name) ?? null;
   }
+  interfaceExtends(name, target, visited = /* @__PURE__ */ new Set()) {
+    const current = this.lookupInterface(name);
+    if (current === null || visited.has(name)) {
+      return false;
+    }
+    visited.add(name);
+    return current.superInterfaces.some((parent) => parent === target || this.interfaceExtends(parent, target, visited));
+  }
   declareEnum(info) {
     this.enums.set(info.name, info);
   }
@@ -4846,24 +4882,42 @@ var DeclarationRegistry = class {
   allEnums() {
     return [...this.enums.values()];
   }
-  collectMembers(className) {
+  collectInterfaceMembers(name, collected, visited) {
+    const current = this.lookupInterface(name);
+    if (current === null || visited.has(current.name)) {
+      return;
+    }
+    visited.add(current.name);
+    for (const [memberName, member] of current.members) {
+      if (!collected.has(memberName)) {
+        collected.set(memberName, member);
+      }
+    }
+    for (const parent of current.superInterfaces) {
+      this.collectInterfaceMembers(parent, collected, visited);
+    }
+  }
+  collectMembers(name) {
     const collected = /* @__PURE__ */ new Map();
     const visited = /* @__PURE__ */ new Set();
-    let current = this.lookupClass(className);
+    let current = this.lookupClass(name);
     while (current !== null && !visited.has(current.name)) {
-      for (const [name, member] of current.members) {
-        if (!collected.has(name)) {
-          collected.set(name, member);
+      for (const [name2, member] of current.members) {
+        if (!collected.has(name2)) {
+          collected.set(name2, member);
         }
       }
       visited.add(current.name);
       current = current.superClass === null ? null : this.lookupClass(current.superClass);
     }
+    if (current === null && this.lookupClass(name) === null) {
+      this.collectInterfaceMembers(name, collected, visited);
+    }
     return [...collected.values()];
   }
-  lookupMember(className, member) {
+  lookupMember(name, member) {
     const visited = /* @__PURE__ */ new Set();
-    let current = this.lookupClass(className);
+    let current = this.lookupClass(name);
     while (current !== null && !visited.has(current.name)) {
       const found = current.members.get(member);
       if (found !== void 0) {
@@ -4872,7 +4926,9 @@ var DeclarationRegistry = class {
       visited.add(current.name);
       current = current.superClass === null ? null : this.lookupClass(current.superClass);
     }
-    return null;
+    const collected = /* @__PURE__ */ new Map();
+    this.collectInterfaceMembers(name, collected, visited);
+    return collected.get(member) ?? null;
   }
 };
 
@@ -4950,6 +5006,35 @@ function mtaMember(className, member) {
   return mtaClassRegistry().lookupMember(className, member);
 }
 
+// ../compiler/src/checker/type-substitution.ts
+function substituteType(type, substitutions) {
+  if (type.kind === "named") {
+    return substitutions.get(type.name) ?? type;
+  }
+  if (type.kind === "array") {
+    return createArray(substituteType(type.element, substitutions));
+  }
+  if (type.kind === "optional") {
+    return createOptional(substituteType(type.element, substitutions));
+  }
+  if (type.kind === "union") {
+    return createUnion(type.options.map((option) => substituteType(option, substitutions)));
+  }
+  if (type.kind === "function") {
+    const parameters = type.parameters.map((parameter) => substituteType(parameter, substitutions));
+    const returnType = substituteType(type.returnType, substitutions);
+    return createFunction(parameters, returnType, type.minimumArguments, type.isVariadic);
+  }
+  if (type.kind === "tuple") {
+    return createTuple(type.elements.map((element) => substituteType(element, substitutions)));
+  }
+  if (type.kind === "record") {
+    const members = new Map([...type.members].map(([name, member]) => [name, substituteType(member, substitutions)]));
+    return createRecord(type.name, members, type.origin);
+  }
+  return type;
+}
+
 // ../compiler/src/checker/context.ts
 var BUILTIN_TYPES = {
   any: ANY_TYPE,
@@ -4987,6 +5072,7 @@ var CheckContext = class {
   methodStack = [];
   projectEnvironments = /* @__PURE__ */ new Map();
   ambientClasses = /* @__PURE__ */ new Set();
+  ambientInterfaces = /* @__PURE__ */ new Set();
   constructor(mode, environment, ambient = EMPTY_AMBIENT, project = EMPTY_PROJECT_DECLARATIONS, oop = false) {
     this.mode = mode;
     this.environment = environment;
@@ -5008,6 +5094,9 @@ var CheckContext = class {
   isAmbientClass(name) {
     return this.ambientClasses.has(name);
   }
+  isAmbientInterface(name) {
+    return this.ambientInterfaces.has(name);
+  }
   noteExternalReference(name, position2) {
     if (!this.externalReferences.has(name)) {
       this.externalReferences.set(name, position2);
@@ -5027,13 +5116,32 @@ var CheckContext = class {
     return this.types.get(expression) ?? UNKNOWN_TYPE;
   }
   pushReturnType(type) {
-    this.returnStack.push(type);
+    this.returnStack.push({ expected: type, inferred: [] });
   }
   popReturnType() {
-    this.returnStack.pop();
+    const frame = this.returnStack.pop();
+    if (frame === void 0 || frame.inferred.length === 0) {
+      return VOID_TYPE;
+    }
+    const tuples = frame.inferred.filter((type) => type.kind === "tuple");
+    const tupleSize = tuples[0]?.kind === "tuple" ? tuples[0].elements.length : null;
+    const sameTupleSize = tuples.length === frame.inferred.length && tuples.every((type) => type.kind === "tuple" && type.elements.length === tupleSize);
+    if (sameTupleSize) {
+      const first = tuples[0];
+      if (first?.kind === "tuple") {
+        const elements = first.elements.map(
+          (_, index) => createUnion(tuples.map((type) => type.kind === "tuple" ? type.elements[index] ?? ANY_TYPE : ANY_TYPE))
+        );
+        return createTuple(elements);
+      }
+    }
+    return createUnion(frame.inferred);
   }
   currentReturnType() {
-    return this.returnStack[this.returnStack.length - 1] ?? null;
+    return this.returnStack[this.returnStack.length - 1]?.expected ?? null;
+  }
+  inferReturnType(type) {
+    this.returnStack[this.returnStack.length - 1]?.inferred.push(type);
   }
   pushClassMethod(frame) {
     this.methodStack.push(frame);
@@ -5057,13 +5165,23 @@ var CheckContext = class {
     if (annotation.kind === "type-union") {
       return createUnion(annotation.options.map((option) => this.resolveAnnotation(option)));
     }
+    if (annotation.kind === "type-object") {
+      const members = /* @__PURE__ */ new Map();
+      for (const member of annotation.members) {
+        members.set(member.name, this.resolveAnnotation(member.annotation));
+      }
+      return createObjectType(members);
+    }
+    if (annotation.kind === "type-tuple") {
+      return createTuple(annotation.elements.map((element) => this.resolveAnnotation(element)));
+    }
     if (annotation.kind === "type-function") {
       const parameters = annotation.parameters.map((parameter) => this.resolveAnnotation(parameter));
       const optional = parameters.findIndex((parameter) => parameter.kind === "optional");
       const minimum = optional === -1 ? parameters.length : optional;
       return createFunction(parameters, this.resolveAnnotation(annotation.returnType), minimum, annotation.isVariadic);
     }
-    return this.resolveNamedAnnotation(annotation.name);
+    return this.resolveNamedAnnotation(annotation.name, annotation.typeArguments, annotation.position);
   }
   expectAssignable(source, target, position2, subject) {
     if (isAssignable(source, target, { allowNil: this.allowNil })) {
@@ -5088,6 +5206,7 @@ var CheckContext = class {
       this.binder.declareGlobal({ name: info.name, type: createNamed(info.name), isLocal: false, position: info.position });
     }
     for (const info of ambient.interfaces) {
+      this.ambientInterfaces.add(info.name);
       this.declarations.declareInterface(info);
     }
     for (const info of ambient.enums) {
@@ -5098,12 +5217,25 @@ var CheckContext = class {
       this.binder.declareGlobal({ name: info.name, type: info.type, isLocal: false, position: info.position });
     }
   }
-  resolveNamedAnnotation(name) {
+  resolveNamedAnnotation(name, typeArguments, position2) {
     const builtin = BUILTIN_TYPES[name];
     if (builtin !== void 0) {
+      if (typeArguments.length > 0) {
+        this.report("check-generic-arity", `Type "${name}" does not accept type arguments.`, position2);
+      }
       return builtin;
     }
-    return this.binder.lookupAlias(name) ?? createNamed(name);
+    const alias = this.binder.lookupAlias(name);
+    if (alias === null) {
+      return createNamed(name);
+    }
+    if (typeArguments.length !== alias.parameters.length) {
+      const expected = alias.parameters.length === 1 ? "1 type argument" : `${alias.parameters.length} type arguments`;
+      this.report("check-generic-arity", `Type "${name}" expects ${expected} but received ${typeArguments.length}.`, position2);
+    }
+    const resolved = typeArguments.map((argument) => this.resolveAnnotation(argument));
+    const substitutions = new Map(alias.parameters.map((parameter, index) => [parameter, resolved[index] ?? ANY_TYPE]));
+    return substituteType(alias.type, substitutions);
   }
 };
 
@@ -5387,7 +5519,7 @@ function expandClassDecorators(context, statement, fieldTypes) {
   const occupied = new Map(statement.members.filter((member) => member.kind === "class-method").map((member) => [member.name, member.name]));
   const classDecorators = validateDecorators(context, statement.decorators, "class");
   for (const member of statement.members) {
-    if (member.kind === "class-method") {
+    if (member.kind === "class-method" || member.name === "constructor") {
       validateDecorators(context, member.decorators, "method");
       continue;
     }
@@ -5969,7 +6101,11 @@ function resolveNamedMember(context, name, expression) {
     return resolveMtaMember(context, name, expression.property, expression.position)?.type ?? ANY_TYPE;
   }
   const contract = context.declarations.lookupClass(name) === null ? context.declarations.lookupInterface(name) : null;
-  return contract === null ? null : checkInterfaceMember(context, name, contract.members, expression);
+  if (contract === null) {
+    return null;
+  }
+  const members = new Map(context.declarations.collectMembers(name).map((member2) => [member2.name, member2]));
+  return checkInterfaceMember(context, name, members, expression);
 }
 var NATIVE_CONSTRUCTOR = "new";
 function nativeConstructor(context, name) {
@@ -6273,7 +6409,7 @@ function checkMultiValueExpression(context, expression) {
       return checkTable(context, expression);
     case "function-expression": {
       const type = buildFunctionType(context, expression.parameters, expression.returnAnnotation);
-      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, null);
+      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, type, null);
       return context.record(expression, type);
     }
     case "binary-expression": {
@@ -6334,8 +6470,16 @@ function registerMembers(context, info, statement) {
   return generated;
 }
 function checkMethodBody(context, info, member) {
+  const explicitSelf = member.parameters.find((parameter) => parameter.name === "self");
+  if (explicitSelf !== void 0) {
+    context.report("check-explicit-self-parameter", 'Class methods receive "self" automatically; remove it from the parameter list.', explicitSelf.position);
+  }
+  const signature = info.members.get(member.name)?.type;
+  if (signature?.kind !== "function") {
+    return;
+  }
   context.pushClassMethod({ className: info.name, methodName: member.name });
-  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, createNamed(info.name));
+  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, createNamed(info.name));
   context.popClassMethod();
 }
 function checkContract(context, info, contract, member) {
@@ -6360,7 +6504,7 @@ function checkInterfaces(context, info) {
       context.report("check-unknown-interface", `Class "${info.name}" implements "${name}", which is not defined.`, info.position);
       continue;
     }
-    for (const member of contract.members.values()) {
+    for (const member of context.declarations.collectMembers(contract.name)) {
       checkContract(context, info, name, member);
     }
   }
@@ -6418,11 +6562,46 @@ function checkInterfaceDeclaration(context, statement) {
     return;
   }
   const members = /* @__PURE__ */ new Map();
+  for (const name of new Set(statement.superInterfaces)) {
+    const parent = context.declarations.lookupInterface(name);
+    if (name === statement.name || context.declarations.interfaceExtends(name, statement.name)) {
+      context.report("check-interface-cycle", `Interface "${statement.name}" creates an inheritance cycle through "${name}".`, statement.position);
+    } else if (parent === null) {
+      context.noteExternalReference(name, statement.position);
+      context.report("check-unknown-interface", `Interface "${statement.name}" extends "${name}", which is not defined.`, statement.position);
+    } else if (context.isAmbientInterface(name)) {
+      context.noteExternalReference(name, statement.position);
+    }
+  }
+  if (new Set(statement.superInterfaces).size !== statement.superInterfaces.length) {
+    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);
-    members.set(member.name, { name: member.name, type, isMethod: member.kind === "interface-method", position: member.position });
+    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);
+    } else {
+      members.set(member.name, info);
+    }
   }
-  context.declarations.declareInterface({ name: statement.name, members, position: statement.position });
+  const inherited = /* @__PURE__ */ new Map();
+  for (const parent of statement.superInterfaces) {
+    for (const member of context.declarations.collectMembers(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))) {
+        context.report("check-conflicting-interface-member", `Interface "${statement.name}" inherits conflicting declarations of "${member.name}".`, statement.position);
+      } else if (existing === void 0) {
+        inherited.set(member.name, member);
+      }
+    }
+  }
+  context.declarations.declareInterface({
+    name: statement.name,
+    superInterfaces: statement.superInterfaces,
+    members,
+    position: statement.position
+  });
 }
 function checkEnumDeclaration(context, statement) {
   if (context.declarations.lookupEnum(statement.name) !== null) {
@@ -6487,9 +6666,9 @@ function buildFunctionType(context, parameters, returnAnnotation) {
   const types = parameters.filter((parameter) => !parameter.isVararg).map((parameter) => context.resolveAnnotation(parameter.annotation));
   return createFunction(types, context.resolveAnnotation(returnAnnotation), minimumArguments(context, parameters), isVariadic);
 }
-function checkFunctionBody(context, parameters, returnAnnotation, body, selfType) {
+function checkFunctionBody(context, parameters, returnAnnotation, body, signature, selfType) {
   context.binder.pushScope();
-  context.pushReturnType(context.resolveAnnotation(returnAnnotation));
+  context.pushReturnType(returnAnnotation === null ? null : context.resolveAnnotation(returnAnnotation));
   if (selfType !== null) {
     context.binder.declare({ name: "self", type: selfType, isLocal: true, position: ORIGIN });
   }
@@ -6498,7 +6677,10 @@ function checkFunctionBody(context, parameters, returnAnnotation, body, selfType
     context.binder.declare({ name: parameter.name, type, isLocal: true, position: parameter.position });
   }
   checkStatements(context, body);
-  context.popReturnType();
+  const inferred = context.popReturnType();
+  if (returnAnnotation === null) {
+    signature.returnType = inferred;
+  }
   context.binder.popScope();
 }
 function valueAt(values, valueTypes, index) {
@@ -6568,12 +6750,16 @@ function checkFunctionDeclaration(context, statement) {
     }
   }
   context.record(statement.name, type);
-  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, statement.isMethod ? ANY_TYPE : null);
+  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null);
 }
 function checkReturn(context, statement) {
   const valueTypes = checkValueList(context, statement.values);
   const expected = context.currentReturnType();
-  if (expected === null || expected.kind === "any") {
+  if (expected === null) {
+    context.inferReturnType(createTuple(valueTypes));
+    return;
+  }
+  if (expected.kind === "any") {
     return;
   }
   if (expected.kind === "void") {
@@ -6582,6 +6768,23 @@ function checkReturn(context, statement) {
     }
     return;
   }
+  if (expected.kind === "tuple") {
+    if (valueTypes.length !== expected.elements.length) {
+      const message = `This function declares ${expected.elements.length} return values but returns ${valueTypes.length}.`;
+      context.report("check-return-mismatch", message, statement.position);
+      return;
+    }
+    valueTypes.forEach((type, index) => {
+      const value2 = statement.values[Math.min(index, statement.values.length - 1)];
+      context.expectAssignable(type, expected.elements[index] ?? ANY_TYPE, value2?.position ?? statement.position, `Return value ${index + 1}`);
+    });
+    return;
+  }
+  if (valueTypes.length > 1) {
+    const message = `This function declares one return value of type "${typeToString(expected)}" but returns ${valueTypes.length} values.`;
+    context.report("check-return-mismatch", message, statement.position);
+    return;
+  }
   const first = valueTypes[0];
   const value = statement.values[0];
   if (first === void 0 || value === void 0) {
@@ -6628,9 +6831,12 @@ function checkStatement(context, statement) {
       return checkNumericFor(context, statement);
     case "generic-for-statement":
       return checkGenericFor(context, statement);
-    case "type-alias-statement":
-      context.binder.declareAlias(statement.name, context.resolveAnnotation(statement.annotation));
+    case "type-alias-statement": {
+      const resolved = context.resolveAnnotation(statement.annotation);
+      const named2 = statement.annotation.kind === "type-object" ? renameRecord(resolved, statement.name) : resolved;
+      context.binder.declareAlias(statement.name, named2, statement.typeParameters);
       return;
+    }
     case "declare-statement":
       return checkDeclareStatement(context, statement);
     case "class-declaration":
@@ -7781,13 +7987,45 @@ function parseFunctionType(stream) {
   return { kind: "type-function", parameters, isVariadic, returnType, position: position2 };
 }
 function parseGroupedType(stream) {
-  stream.expect("punctuation", "(");
+  const position2 = stream.expect("punctuation", "(").position;
   const inner = parseTypeAnnotation(stream);
-  if (stream.check("punctuation", ",")) {
-    throw stream.error("A parenthesized type must contain a single type.", "parse-invalid-type");
+  if (!stream.match("punctuation", ",")) {
+    stream.expect("punctuation", ")");
+    return inner;
   }
+  const elements = [inner];
+  do {
+    elements.push(parseTypeAnnotation(stream));
+  } while (stream.match("punctuation", ","));
   stream.expect("punctuation", ")");
-  return inner;
+  return { kind: "type-tuple", elements, position: position2 };
+}
+function parseObjectMember(stream) {
+  const token = stream.expectName();
+  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");
+  }
+  return { name: token.value, annotation, position: token.position };
+}
+function parseObjectType(stream) {
+  const position2 = stream.expect("punctuation", "{").position;
+  const members = [];
+  const declared = /* @__PURE__ */ new Set();
+  while (!stream.check("punctuation", "}") && !stream.isEof()) {
+    if (stream.match("punctuation", ";") || stream.match("punctuation", ",")) {
+      continue;
+    }
+    const member = parseObjectMember(stream);
+    if (declared.has(member.name)) {
+      stream.report("parse-duplicate-key", `Object type key "${member.name}" is declared more than once.`, member.position);
+      continue;
+    }
+    declared.add(member.name);
+    members.push(member);
+  }
+  stream.expect("punctuation", "}");
+  return { kind: "type-object", members, position: position2 };
 }
 function parsePrimaryType(stream) {
   if (stream.check("keyword", "function")) {
@@ -7796,6 +8034,9 @@ function parsePrimaryType(stream) {
   if (stream.check("identifier", FUNCTION_TYPE)) {
     return parseFunctionType(stream);
   }
+  if (stream.check("punctuation", "{")) {
+    return parseObjectType(stream);
+  }
   return stream.check("punctuation", "(") ? parseGroupedType(stream) : parseTypeName(stream);
 }
 function parsePostfixType(stream) {
@@ -8125,16 +8366,24 @@ function parseForStatement(stream) {
 }
 
 // ../compiler/src/parser/recovery.ts
-function recoverInBlock(stream, error) {
+var BRACE_TERMINATORS = /* @__PURE__ */ new Set(["}"]);
+function isTerminator(stream, terminators) {
+  const token = stream.current();
+  if (token.kind !== "punctuation" && token.kind !== "keyword") {
+    return false;
+  }
+  return terminators.has(token.value);
+}
+function recoverInBlock(stream, error, terminators = BRACE_TERMINATORS) {
   stream.diagnostics.push(error.diagnostic);
   if (stream.isEof()) {
     return;
   }
   const start = stream.current();
-  while (!stream.isEof() && !stream.check("punctuation", "}") && stream.current().position.line === start.position.line) {
+  while (!stream.isEof() && !isTerminator(stream, terminators) && stream.current().position.line === start.position.line) {
     stream.next();
   }
-  if (!stream.isEof() && !stream.check("punctuation", "}") && stream.current().position.offset === start.position.offset) {
+  if (!stream.isEof() && !isTerminator(stream, terminators) && stream.current().position.offset === start.position.offset) {
     stream.next();
   }
 }
@@ -8244,7 +8493,10 @@ function isDeclarationStart(stream) {
   if (offset > 0 && token.value !== "class") {
     return false;
   }
-  return token.value === "class" ? isClassHeader(stream, offset) : stream.checkAhead(offset + 2, "punctuation", "{");
+  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", "{");
 }
 function skipDecoratorArguments(stream) {
   let depth = 0;
@@ -8271,6 +8523,21 @@ function parseDecorators(stream) {
   return decorators;
 }
 function parseClassMethod(stream, token, decorators) {
+  stream.expect("operator", "=");
+  const expression = parseFunctionExpression(stream);
+  return {
+    kind: "class-method",
+    name: token.value,
+    isConstructor: token.value === "constructor",
+    isSynthetic: false,
+    parameters: expression.parameters,
+    returnAnnotation: expression.returnAnnotation,
+    body: expression.body,
+    decorators,
+    position: token.position
+  };
+}
+function parseLegacyClassMethod(stream, token, decorators) {
   const parameters = parseParameters(stream);
   const returnAnnotation = parseOptionalAnnotation(stream);
   const body = parseBraceBlock(stream);
@@ -8289,14 +8556,26 @@ function parseClassMethod(stream, token, decorators) {
 function parseFieldAnnotation(stream) {
   return parseNamedAnnotation(stream, "field");
 }
+function expectClassFieldBoundary(stream, token) {
+  const current = stream.current();
+  const delimiter = current.kind === "punctuation" && (current.value === "}" || current.value === ";" || current.value === ",");
+  if (current.kind === "eof" || delimiter || current.position.line > token.position.line) {
+    return;
+  }
+  throw stream.error(`Expected a line break or separator after class member "${token.value}".`, "parse-unexpected-token");
+}
 function parseClassMember(stream) {
   const decorators = parseDecorators(stream);
   const token = stream.expectName();
   if (stream.check("punctuation", "(")) {
+    return parseLegacyClassMethod(stream, token, decorators);
+  }
+  if (stream.check("operator", "=") && stream.checkAhead(1, "keyword", "function")) {
     return parseClassMethod(stream, token, decorators);
   }
   const annotation = parseFieldAnnotation(stream);
   const value = stream.match("operator", "=") ? parseExpression(stream) : null;
+  expectClassFieldBoundary(stream, token);
   return { kind: "class-field", name: token.value, annotation, value, decorators, position: token.position };
 }
 function parseClassModifiers(stream, declaration) {
@@ -8348,7 +8627,13 @@ function parseInterfaceMember(stream) {
 function parseInterfaceDeclaration(stream) {
   const position2 = stream.next().position;
   const name = stream.expect("identifier").value;
+  const superInterfaces = [];
   const members = [];
+  if (stream.match("keyword", "extends")) {
+    do {
+      superInterfaces.push(stream.expect("identifier").value);
+    } while (stream.match("punctuation", ","));
+  }
   stream.expect("punctuation", "{");
   while (!stream.check("punctuation", "}") && !stream.isEof()) {
     if (stream.match("punctuation", ";") || stream.match("punctuation", ",")) {
@@ -8364,7 +8649,7 @@ function parseInterfaceDeclaration(stream) {
     }
   }
   stream.expect("punctuation", "}");
-  return { kind: "interface-declaration", name, members, position: position2 };
+  return { kind: "interface-declaration", name, superInterfaces, members, position: position2 };
 }
 function parseEnumDeclaration(stream) {
   const position2 = stream.next().position;
@@ -8564,14 +8849,14 @@ function parseStatement(stream) {
   }
   return parseExpressionStatement(stream);
 }
-function parseBlockStatement(stream) {
+function parseBlockStatement(stream, terminators = BRACE_TERMINATORS) {
   try {
     return parseStatement(stream);
   } catch (error) {
     if (!(error instanceof ParserError)) {
       throw error;
     }
-    recoverInBlock(stream, error);
+    recoverInBlock(stream, error, terminators);
     return null;
   }
 }
@@ -8604,7 +8889,14 @@ function parseBlock(stream, terminators) {
     if (stream.current().kind === "keyword" && stop.has(stream.current().value)) {
       return body;
     }
-    const statement = parseStatement(stream);
+    const offset = stream.current().position.offset;
+    const statement = parseBlockStatement(stream, stop);
+    if (statement === null) {
+      if (stream.current().position.offset === offset) {
+        return body;
+      }
+      continue;
+    }
     body.push(statement);
     if (statement.kind === "return-statement") {
       return body;
@@ -8751,7 +9043,7 @@ function classText(info) {
   return `class ${info.name}:${info.superClass ?? ""}:${[...info.interfaces].sort(compareText).join(",")}{${membersText(info.members)}}`;
 }
 function interfaceText(info) {
-  return `interface ${info.name}{${membersText(info.members)}}`;
+  return `interface ${info.name}:${[...info.superInterfaces].sort(compareText).join(",")}{${membersText(info.members)}}`;
 }
 function enumText(info) {
   return `enum ${info.name}{${info.members.join(",")}}`;
@@ -10792,6 +11084,28 @@ async function runDevCommand(context, options) {
 // src/commands/init-command.ts
 import { basename } from "node:path";
 
+// src/commands/init-prompt.ts
+import { createInterface } from "node:readline/promises";
+async function question(prompt, label2, fallback) {
+  const answer = (await prompt.question(`${label2}${fallback === "" ? "" : ` (${fallback})`}: `)).trim();
+  return answer === "" ? fallback : answer;
+}
+async function promptForProject(defaults, nameLocked) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return defaults;
+  }
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const name = nameLocked ? defaults.name : await question(prompt, "Project name", defaults.name);
+    const version = await question(prompt, "Version", defaults.version);
+    const description = await question(prompt, "Description", defaults.description ?? "");
+    const author = await question(prompt, "Author", defaults.author ?? "");
+    return { name, version, description: description || null, author: author || null };
+  } finally {
+    prompt.close();
+  }
+}
+
 // src/config/config-schema.ts
 var CONFIG_FILE_NAME = "luam.json";
 var DEFAULT_SOURCE_DIRS = ["src"];
@@ -10839,21 +11153,29 @@ function readTemplateSource(source) {
 }
 
 // src/scaffold/scaffold-plan.ts
-function renderConfig(source, name) {
+function renderConfig(source, details) {
   const parsed = JSON.parse(source);
   const config = typeof parsed === "object" && parsed !== null ? parsed : {};
-  return `${JSON.stringify({ ...config, name, description: `The ${name} resource, scaffolded by luam init.` }, null, 4)}
+  const { name: _name, version: _version, description: _description, author: _author, ...template } = config;
+  const metadata = {
+    ...template,
+    name: details.name,
+    version: details.version,
+    ...details.description === null ? {} : { description: details.description },
+    ...details.author === null ? {} : { author: details.author }
+  };
+  return `${JSON.stringify(metadata, null, 4)}
 `;
 }
-function renderFile(file, name) {
+function renderFile(file, details) {
   const source = readTemplateSource(file.source);
   if (file.path !== CONFIG_FILE_NAME) {
     return { path: file.path, content: source };
   }
-  return { path: file.path, content: renderConfig(source, name) };
+  return { path: file.path, content: renderConfig(source, details) };
 }
-function buildScaffoldPlan(name) {
-  return { name, files: TEMPLATE_FILES.map((file) => renderFile(file, name)) };
+function buildScaffoldPlan(details) {
+  return { name: details.name, files: TEMPLATE_FILES.map((file) => renderFile(file, details)) };
 }
 
 // src/scaffold/scaffold-writer.ts
@@ -10884,21 +11206,31 @@ function resolveResourceName(root, requested) {
   const folder = basename(root);
   return isValidResourceName(folder) ? folder : FALLBACK_RESOURCE_NAME;
 }
-function runInitCommand(root, logger, options) {
+async function runInitCommand(root, logger, options) {
   if (options.name !== null && !isValidResourceName(options.name)) {
     logger.error(`"--name" must be a valid MTA resource name but received "${options.name}".`);
     return EXIT_USAGE;
   }
-  const name = resolveResourceName(root, options.name);
-  const result = writeScaffold(root, buildScaffoldPlan(name), options.force);
+  const defaults = {
+    name: resolveResourceName(root, options.name),
+    version: "1.0.0",
+    description: null,
+    author: null
+  };
+  const details = options.yes ? defaults : await options.prompt(defaults, options.name !== null);
+  if (!isValidResourceName(details.name)) {
+    logger.error(`"Project name" must be a valid MTA resource name but received "${details.name}".`);
+    return EXIT_USAGE;
+  }
+  const result = writeScaffold(root, buildScaffoldPlan(details), options.force);
   for (const path of result.skipped) {
     logger.warn(`Kept the existing "${path}". Pass "--force" to overwrite it.`);
   }
   if (result.written.length === 0) {
-    logger.info(`The project "${name}" already exists in "${root}". Nothing was written.`);
+    logger.info(`The project "${details.name}" already exists in "${root}". Nothing was written.`);
     return EXIT_OK;
   }
-  logger.info(`Scaffolded "${name}" into "${root}" (${result.written.length} files, ${result.skipped.length} kept).`);
+  logger.info(`Scaffolded "${details.name}" into "${root}" (${result.written.length} files, ${result.skipped.length} kept).`);
   logger.info('Next: run "luam check", then "luam build".');
   return EXIT_OK;
 }
@@ -11510,12 +11842,12 @@ function createEditorService() {
 }
 
 // src/editor/installation-prompt.ts
-import { createInterface } from "node:readline/promises";
+import { createInterface as createInterface2 } from "node:readline/promises";
 async function promptForInstallation(editorName) {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     return null;
   }
-  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = createInterface2({ input: process.stdin, output: process.stdout });
   try {
     const answer = (await prompt.question(`Install the Luam extension in ${editorName}? [Y/n] `)).trim().toLowerCase();
     return answer === "" || answer === "y" || answer === "yes";
@@ -11638,7 +11970,8 @@ async function runCli(argv, overrides = {}) {
   }
   const root = resolve12(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
   if (parsed.command === "init") {
-    return runInitCommand(root, logger, { name: parsed.name, force: parsed.force });
+    const target = parsed.operand === null ? root : resolve12(root, parsed.operand);
+    return runInitCommand(target, logger, { name: parsed.name, force: parsed.force, yes: parsed.yes, prompt: overrides.initPrompt ?? promptForProject });
   }
   const editorService = overrides.editorService ?? createEditorService();
   if (parsed.command === "doctor") {