@thigasdevelopment/luam 0.2.1 → 0.4.0

package/luam.mjs

@@ -212,7 +212,7 @@ 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.0" : "0.0.0-dev";
 var USAGE = [
   "luam \u2014 the Luam compiler for Multi Theft Auto resources.",
   "",
@@ -916,6 +916,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 +1031,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 +1077,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);
   }
@@ -4831,6 +4858,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 +4881,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 +4925,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;
   }
 };
 
@@ -4987,6 +5042,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 +5064,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);
@@ -5057,6 +5116,16 @@ 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");
@@ -5088,6 +5157,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) {
@@ -5387,7 +5457,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 +6039,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) {
@@ -6334,6 +6408,10 @@ 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);
+  }
   context.pushClassMethod({ className: info.name, methodName: member.name });
   checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, createNamed(info.name));
   context.popClassMethod();
@@ -6360,7 +6438,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 +6496,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);
+    }
+  }
+  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, members, position: statement.position });
+  context.declarations.declareInterface({
+    name: statement.name,
+    superInterfaces: statement.superInterfaces,
+    members,
+    position: statement.position
+  });
 }
 function checkEnumDeclaration(context, statement) {
   if (context.declarations.lookupEnum(statement.name) !== null) {
@@ -6582,6 +6695,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 +6758,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);
       return;
+    }
     case "declare-statement":
       return checkDeclareStatement(context, statement);
     case "class-declaration":
@@ -7781,13 +7914,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 +7961,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 +8293,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 +8420,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 +8450,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);
@@ -8293,6 +8487,9 @@ 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);
@@ -8348,7 +8545,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 +8567,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 +8767,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 +8807,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 +8961,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(",")}}`;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thigasdevelopment/luam",
-    "version": "0.2.1",
+    "version": "0.4.0",
     "description": "The Luam compiler for Multi Theft Auto resources.",
     "keywords": [
         "mta",

package/template/README.md

@@ -1,120 +0,0 @@
-# luam-resource
-
-A Luam resource scaffolded by `luam init`. Write `.luam` sources under `src`, run
-`luam build`, and MTA gets a plain Lua 5.1 resource in `build/luam-resource`.
-
-## Commands
-
-| Command | Behavior |
-| ------- | -------- |
-| `luam check` | Compiles and reports diagnostics. Writes nothing. |
-| `luam build` | Writes the resource into `build/luam-resource`. |
-| `luam ensure` | Builds, syncs into the MTA server, restarts, and watches sources. |
-
-Set `serverPath` in `luam.json` before running `luam ensure`.
-
-## Layout
-
-```
-.env                         Declares deployment keys and safe defaults
-config.lua                   Structural settings the resource owns
-assets/                      Files copied verbatim and downloaded by clients
-src/
-  shared/
-    config.luam              Constants and helpers both sides use
-    framework/               Core, Event, Listener, Command, Loader, ThreadPool
-  server/
-    main.luam                Creates the server Core and starts it
-    handlers/                One file per server listener
-    commands/                One file per server command
-  client/
-    main.luam                Creates the client Core and starts it
-    commands/                One file per client command
-```
-
-The generated resource mirrors this tree. `src/server/main.luam` becomes
-`src/server/main.lua`, and runtime helpers land in `src/<environment>/lib`, so a
-server-only helper is never downloaded by a client.
-
-## Configuration
-
-Two files hold settings, and they have different owners.
-
-`config.lua` belongs to the resource author. It is plain Lua, copied verbatim,
-listed in `meta.xml` as a shared script, and readable by clients. Anything a
-player may see belongs here.
-
-`.env` belongs to the deployment. It declares the keys and safe defaults, and it
-is the source of truth for their types: an unquoted number is a number, `true`
-and `false` are booleans, and quoting forces a string. Override values locally in
-`.env.local`, which is never committed.
-
-The first `luam build` writes `build/<resource>/.env` from those keys, leaving
-sensitive values blank, and never overwrites it again — that file belongs to the
-server administrator.
-
-Values reach Luam through `process.env`, which exists only on the server:
-
-```lua
-outputServerLog(tostring(process.env.SERVER_NAME))
-```
-
-A key that `.env` does not declare is a compile error, and `process` in a client
-or shared file is a compile error too.
-
-## Framework
-
-`Core` owns the resource lifecycle. `main.luam` creates it with the side it runs
-on and calls `start()` once the resource has finished loading. `start()` scans
-the class registry, instantiates every `Listener` and `Command` subclass with the
-`Core` instance, and registers them.
-
-### Listeners
-
-A listener declares the MTA event it handles and overrides `handle`. Nothing
-registers it by hand — being a `Listener` subclass is enough.
-
-```lua
-class PlayerQuitListener extends Listener {
-    event: string = 'onPlayerQuit'
-
-    handle(...): void {
-        outputDebugString(getPlayerName(source) .. ' left.')
-    }
-}
-```
-
-`element` defaults to `root`. Set it to narrow the handler to one element.
-
-### Commands
-
-A command declares its name, optional aliases, and overrides `execute`. Every
-name and alias is registered.
-
-```lua
-class KickCommand extends Command {
-    name: string = 'kick'
-    aliases: string[] = { 'k' }
-    description: string = 'Kicks a player by name.'
-
-    execute(player: any, ...): void {
-        local args: any = { ... }
-
-        kickPlayer(getPlayerFromName(args[1]), player, 'kicked')
-    }
-}
-```
-
-On the server `execute` receives the calling player; on the client the first
-parameter is `nil`.
-
-### Threads
-
-`ThreadPool` wraps the `threads.lua` runtime helper, which is opt-in. Add it to
-`luam.json` before using the class:
-
-```json
-{
-    "helpers": ["threads"]
-}
-```

package/template/config.lua

@@ -1,14 +0,0 @@
-Config = {
-    greeting = 'Welcome to the server.',
-
-    spawn = {
-        x = 1959.55,
-        y = -1714.46,
-        z = 10.0,
-    },
-
-    ping = {
-        limit = 250,
-        warnAt = 180,
-    },
-}

package/template/env

@@ -1,11 +0,0 @@
-# Deployment values. This file is versioned and declares the keys and safe
-# defaults. Types come from this file: an unquoted number is a number, "true"
-# and "false" are booleans, and quoting forces a string.
-#
-# Override values on your machine in ".env.local", which is never committed.
-# The server administrator edits the generated "build/.env" instead.
-
-# Server
-SERVER_NAME="Luam Server"
-MAX_PLAYERS=32
-DEBUG=false

package/template/framework/bootstrap-client.luam

@@ -1,9 +0,0 @@
-local core: Core = new Core('client')
-
-addEventHandler('onClientResourceStart', resourceRoot, function()
-    core:start()
-end)
-
-addEventHandler('onClientResourceStop', resourceRoot, function()
-    core:stop()
-end)

package/template/framework/bootstrap-server.luam

@@ -1,9 +0,0 @@
-local core: Core = new Core('server')
-
-addEventHandler('onResourceStart', resourceRoot, function()
-    core:start()
-end)
-
-addEventHandler('onResourceStop', resourceRoot, function()
-    core:stop()
-end)