@thigasdevelopment/luam 0.19.2 → 0.19.3

package/luam.mjs

@@ -3253,7 +3253,7 @@ var EXIT_USAGE = 2;
 // src/config/manifest-context.ts
 var DEVELOPMENT_MODE = "development";
 var PRODUCTION_MODE = "production";
-var DEVELOPMENT_COMMANDS = ["dev", "ensure", "server"];
+var DEVELOPMENT_COMMANDS = ["dev", "ensure", "server", "test"];
 var PRODUCTION_COMMANDS = ["build"];
 function manifestMode(command) {
   if (DEVELOPMENT_COMMANDS.includes(command)) {
@@ -6762,7 +6762,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.19.2" : "0.0.0-dev";
+var VERSION = true ? "0.19.3" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -8313,7 +8313,7 @@ import { resolve as resolve8 } from "node:path";
 function createSourceResolver(mapping) {
   const matchers = new Map(SOURCE_SIDES.map((environment) => [environment, createPatternMatcher(mapping[environment])]));
   const patterns = SOURCE_SIDES.flatMap((environment) => [...matchers.get(environment)?.patterns ?? []]);
-  function resolve19(path) {
+  function resolve21(path) {
     const normalized = normalizePattern(path);
     const matches = [];
     for (const environment of SOURCE_SIDES) {
@@ -8327,8 +8327,8 @@ function createSourceResolver(mapping) {
   return {
     patterns,
     roots: watchRoots(patterns),
-    resolve: resolve19,
-    side: (path) => resolve19(path).environment
+    resolve: resolve21,
+    side: (path) => resolve21(path).environment
   };
 }
 function describeMatches(matches) {
@@ -8338,17 +8338,28 @@ function describeMatches(matches) {
 // ../compiler/src/project/source-kind.ts
 var SOURCE_EXTENSION = ".luam";
 var DECLARATION_EXTENSION = ".d.luam";
+var TEST_EXTENSION = ".test.luam";
 function isDeclarationPath(path) {
   return normalizePath(path).endsWith(DECLARATION_EXTENSION);
 }
+function isTestPath(path) {
+  return normalizePath(path).endsWith(TEST_EXTENSION);
+}
 
 // src/build/source-discovery.ts
 var MISSING_SOURCE = "config-missing-source";
 var NO_SOURCES = "config-no-sources";
 var SIDE_CONFLICT = "config-source-side-conflict";
+var TEST_SOURCE = "config-test-source";
 var UNREADABLE_SOURCE = "build-source-unreadable";
 function checkLiterals(root, resolver, found, diagnostics) {
   for (const pattern of resolver.patterns.filter(isLiteralPattern)) {
+    if (isTestPath(pattern)) {
+      diagnostics.push(
+        cliError(TEST_SOURCE, `"${pattern}" is listed in "sources" but "${TEST_EXTENSION}" files are run by "luam test" and never built into the resource.`)
+      );
+      continue;
+    }
     if (!pattern.endsWith(SOURCE_EXTENSION)) {
       diagnostics.push(cliError(MISSING_SOURCE, `"${pattern}" is listed in "sources" but does not end in "${SOURCE_EXTENSION}".`));
       continue;
@@ -8372,7 +8383,7 @@ function discoverSources(root, sources, excluded = []) {
   const diagnostics = tree.errors.map((message) => cliError(UNREADABLE_SOURCE, message));
   const files = [];
   const matched = /* @__PURE__ */ new Set();
-  for (const path of tree.files.filter((entry) => entry.endsWith(SOURCE_EXTENSION))) {
+  for (const path of tree.files.filter((entry) => entry.endsWith(SOURCE_EXTENSION) && !isTestPath(entry))) {
     const resolution = resolver.resolve(path);
     if (resolution.matches.length === 0) {
       continue;
@@ -8458,6 +8469,37 @@ function projectDeclarations(entries3, origin) {
   return { globals: [envDeclaration(entries3, origin)] };
 }
 
+// ../compiler/src/checker/test-declarations.ts
+var TEST_ORIGIN = "luam:test";
+var CALLBACK = fn([], VOID);
+var EXPECTATION_MEMBERS = [
+  { name: "toBe", type: fn([ANY], VOID, 1, false, ["expected"]) },
+  { name: "toBeFalsy", type: fn([], VOID) },
+  { name: "toBeNil", type: fn([], VOID) },
+  { name: "toBeTruthy", type: fn([], VOID) },
+  { name: "toContain", type: fn([ANY], VOID, 1, false, ["value"]) },
+  { name: "toEqual", type: fn([ANY], VOID, 1, false, ["expected"]) },
+  { name: "toNotBe", type: fn([ANY], VOID, 1, false, ["expected"]) },
+  { name: "toNotEqual", type: fn([ANY], VOID, 1, false, ["expected"]) },
+  { name: "toThrow", type: fn([optionalOf(STRING)], VOID, 0, false, ["message"]) }
+];
+var STUB_MEMBERS = [
+  { name: "calls", type: fn([STRING], arrayOf(TABLE), 1, false, ["name"]) },
+  { name: "reset", type: fn([], VOID) },
+  { name: "returns", type: fn([STRING, ANY], VOID, 2, false, ["name", "value"]) },
+  { name: "stub", type: fn([STRING, ANY], VOID, 2, false, ["name", "implementation"]) }
+];
+var EXPECTATION_TYPE = record("Expectation", EXPECTATION_MEMBERS, TEST_ORIGIN);
+var MTA_STUBS_TYPE = record("MtaStubs", STUB_MEMBERS, TEST_ORIGIN);
+var TEST_DECLARATIONS = [
+  { name: "afterEach", environment: "shared", source: "extension", type: fn([CALLBACK], VOID, 1, false, ["body"]) },
+  { name: "beforeEach", environment: "shared", source: "extension", type: fn([CALLBACK], VOID, 1, false, ["body"]) },
+  { name: "describe", environment: "shared", source: "extension", type: fn([STRING, CALLBACK], VOID, 2, false, ["name", "body"]) },
+  { name: "expect", environment: "shared", source: "extension", type: fn([ANY], EXPECTATION_TYPE, 1, false, ["value"]) },
+  { name: "mta", environment: "shared", source: "extension", type: MTA_STUBS_TYPE },
+  { name: "test", environment: "shared", source: "extension", type: fn([STRING, CALLBACK], VOID, 2, false, ["name", "body"]) }
+];
+
 // ../compiler/src/checker/ambient.ts
 var EVENT_NAME_PREFIX = "event:";
 var EMPTY_AMBIENT = { classes: [], interfaces: [], enums: [], globals: [], events: [] };
@@ -20517,8 +20559,8 @@ function typeOf(state, expression) {
 function indentLine(state, text) {
   return `${INDENT2.repeat(state.indent)}${text}`;
 }
-function markSource(state, sourceLine, symbol = state.symbol) {
-  const marker = { sourceLine };
+function markSource(state, sourceLine2, symbol = state.symbol) {
+  const marker = { sourceLine: sourceLine2 };
   if (symbol !== void 0) {
     marker.symbol = symbol;
   }
@@ -22185,7 +22227,7 @@ function compileModule(file, ambient, context) {
     ...file.environment === void 0 ? {} : { environment: file.environment },
     ambient,
     contracts: context.contracts,
-    project: context.project,
+    project: isTestPath(file.path) ? context.testProject : context.project,
     projectReferences: context.projectReferences,
     compilerOptions: context.compilerOptions,
     development: context.development
@@ -22273,6 +22315,7 @@ function createProjectCache() {
         scope: createAmbientScope(collected, { project, references: projectReferences, options: compilerOptions, development, contracts }),
         contracts,
         project,
+        testProject: { globals: [...project.globals, ...TEST_DECLARATIONS] },
         projectReferences,
         compilerOptions,
         development
@@ -22363,6 +22406,7 @@ function runCompile(root, config, options = {}) {
   const excluded = [config.outDir, config.contracts];
   const sources = discoverSources(root, config.sources, excluded);
   const inputs = readProjectInputs(root, { assets: config.assets, environment: config.environment, excluded });
+  const files = [...sources.files, ...options.additionalFiles ?? []].sort((left, right) => left.path.localeCompare(right.path));
   const contracts = readDependencyContracts(root, config);
   const diagnostics = [...sources.diagnostics, ...inputs.diagnostics, ...contracts.diagnostics];
   if (hasCliErrors(diagnostics)) {
@@ -22381,9 +22425,9 @@ function runCompile(root, config, options = {}) {
       contract: null
     };
   }
-  tracker.begin("compile", sources.files.length);
+  tracker.begin("compile", files.length);
   const declarations = projectDeclarations(inputs.declared?.entries ?? null, config.environment.file);
-  const project = cache3.compile(sources.files, {
+  const project = cache3.compile(files, {
     project: declarations,
     contracts: contracts.contracts,
     compilerOptions: config.compilerOptions,
@@ -22406,12 +22450,12 @@ function runCompile(root, config, options = {}) {
     build,
     diagnostics,
     fileDiagnostics: assembly.diagnostics,
-    fileCount: sources.files.length,
+    fileCount: files.length,
     durationMs: performance.now() - started,
     stats: project.stats,
     environmentTemplate: inputs.deployed === null ? null : renderEnvironmentTemplate(inputs.deployed),
     phases: tracker.durations(),
-    sources: diagnosticSources(sources.files, assembly.diagnostics),
+    sources: diagnosticSources(files, assembly.diagnostics),
     map: build?.map ?? null,
     contract: build === null ? null : buildResourceAbi(config.name, project.modules.flatMap((module) => module.contributions))
   };
@@ -23783,14 +23827,14 @@ function parseMtaLogLine(line2, activeResource, fallback = /* @__PURE__ */ new D
     const level = severity?.[1] === void 0 ? "info" : logLevel(severity[1]) ?? "info";
     const message = stamped.rest.replace(resource[0], "").replace(severity?.[0] ?? "", "").replace(/^\s*[:|-]?\s*/, "");
     const sourcePath = resource[2];
-    const sourceLine = resource[3];
+    const sourceLine2 = resource[3];
     return {
       timestamp: stamped.value,
       environment: "server",
       level,
       message,
       resource: activeResource,
-      ...sourcePath !== void 0 && sourceLine !== void 0 ? { source: { path: sourcePath, line: Number(sourceLine) } } : {}
+      ...sourcePath !== void 0 && sourceLine2 !== void 0 ? { source: { path: sourcePath, line: Number(sourceLine2) } } : {}
     };
   }
   return { timestamp: stamped.value, environment: "server", level: "info", message: stamped.rest, resource: activeResource };
@@ -24235,9 +24279,52 @@ function registerDevCommand(program2, runtime) {
   });
 }
 
+// src/testing/lua-interpreter.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+var REQUIRED_LUA_VERSION = "Lua 5.1";
+var LUA_CANDIDATES = ["lua5.1", "lua51", "lua", "luajit"];
+var LUA_ENV_VARIABLE = "LUAM_LUA";
+var INSTALL_HINT = 'Install a Lua 5.1 interpreter and put it on PATH, or point "--lua" or the LUAM_LUA variable at one. LuaJIT reports "Lua 5.1" and is accepted.';
+function probeInterpreter(executable) {
+  const result = spawnSync2(executable, ["-e", "io.write(_VERSION)"], { encoding: "utf8", shell: false, windowsHide: true });
+  if (result.error !== void 0 || result.status !== 0) {
+    return null;
+  }
+  return result.stdout.trim();
+}
+function findLuaInterpreter(request = {}) {
+  const probe = request.probe ?? probeInterpreter;
+  const pinned = request.explicit ?? request.env ?? null;
+  const candidates3 = pinned === null ? LUA_CANDIDATES : [pinned];
+  for (const executable of candidates3) {
+    const version = probe(executable);
+    if (version === REQUIRED_LUA_VERSION) {
+      return { executable, version };
+    }
+  }
+  return null;
+}
+function describeMissingInterpreter(request = {}) {
+  const pinned = request.explicit ?? request.env ?? null;
+  if (pinned !== null) {
+    return `"${pinned}" is not a ${REQUIRED_LUA_VERSION} interpreter.`;
+  }
+  return `No ${REQUIRED_LUA_VERSION} interpreter was found on PATH (tried ${LUA_CANDIDATES.map((name) => `"${name}"`).join(", ")}).`;
+}
+
 // src/commands/doctor-command.ts
-function runDoctorCommand(reporter, editorService) {
+function reportInterpreter(reporter, probe) {
+  const interpreter = findLuaInterpreter(probe === void 0 ? {} : { probe });
+  if (interpreter === null) {
+    reporter.warn(`No ${REQUIRED_LUA_VERSION} interpreter was found on PATH, so "luam test" cannot run.`);
+    reporter.detail(INSTALL_HINT);
+    return;
+  }
+  reporter.success(`"${interpreter.executable}" reports ${interpreter.version} and can run "luam test".`);
+}
+function runDoctorCommand(reporter, editorService, probe) {
   reporter.success(`Luam CLI ${VERSION} is running on Node.js ${process.versions.node}.`);
+  reportInterpreter(reporter, probe);
   const editors = editorService.detect();
   if (editors.length === 0) {
     reporter.warn("No supported editor command was found on PATH.");
@@ -24565,8 +24652,635 @@ function registerServerCommand(program2, runtime) {
   });
 }
 
+// src/testing/test-report.ts
+import { readFileSync as readFileSync11 } from "node:fs";
+import { resolve as resolve19 } from "node:path";
+function sourceLine(root, path, line2, cache3) {
+  let lines = cache3.get(path);
+  if (lines === void 0) {
+    try {
+      lines = readFileSync11(resolve19(root, path), "utf8").split(/\r?\n/);
+    } catch {
+      lines = [];
+    }
+    cache3.set(path, lines);
+  }
+  return lines[line2 - 1] ?? null;
+}
+function columnOf(text, symbol) {
+  if (text === null) {
+    return 1;
+  }
+  const symbolIndex = symbol === void 0 ? -1 : text.indexOf(symbol);
+  if (symbolIndex >= 0) {
+    return symbolIndex + 1;
+  }
+  const indent = /^\s*/.exec(text)?.[0].length ?? 0;
+  return indent + 1;
+}
+function resolveTestPosition(root, map, result, cache3) {
+  if (map === null || result.file === null || result.line === null) {
+    return null;
+  }
+  const resolution = resolveResourcePosition(map, result.file, result.line);
+  if (resolution.status !== "resolved") {
+    return null;
+  }
+  const { file, line: line2, symbol } = resolution.position;
+  return { path: file, line: line2, column: columnOf(sourceLine(root, file, line2, cache3), symbol) };
+}
+function formatLocation(root, map, result, cache3) {
+  const position2 = resolveTestPosition(root, map, result, cache3);
+  if (position2 !== null) {
+    return `${position2.path}:${position2.line}:${position2.column}`;
+  }
+  return result.file === null || result.line === null ? "unknown position" : `${result.file}:${result.line}`;
+}
+function countResults(runs) {
+  const results = runs.flatMap((run) => run.results);
+  const passed = results.filter((result) => result.passed).length;
+  return { passed, failed: results.length - passed };
+}
+function reportTestResults(reporter, runs, root, map, durationMs) {
+  const cache3 = /* @__PURE__ */ new Map();
+  const marker = (name) => reporter.style.marker(name);
+  for (const run of runs) {
+    for (const line2 of run.output) {
+      reporter.detail(`  ${line2}`);
+    }
+    for (const result of run.results) {
+      const tone = result.passed ? "success" : "error";
+      const label2 = `${result.environment} \xB7 ${result.name}`;
+      reporter.raw(`  ${reporter.style.paint(tone, marker(result.passed ? "success" : "failure"))} ${label2}`);
+      if (!result.passed) {
+        reporter.rawError(`      ${formatLocation(root, map, result, cache3)} ${result.message}`);
+      }
+    }
+    if (run.failure !== null) {
+      reporter.error(`The ${run.environment} test run did not complete: ${run.failure}`);
+    }
+  }
+  const totals = countResults(runs);
+  const summary = `${pluralize(totals.passed, "test")} passed, ${totals.failed} failed in ${formatDuration(durationMs)}.`;
+  const crashed = runs.some((run) => run.failure !== null);
+  if (totals.failed === 0 && !crashed) {
+    reporter.success(`Tests passed: ${summary}`);
+    return true;
+  }
+  reporter.error(`Tests failed: ${summary}`);
+  return false;
+}
+
+// src/testing/test-discovery.ts
+import { readFileSync as readFileSync12 } from "node:fs";
+import { resolve as resolve20 } from "node:path";
+var DEFAULT_TEST_ENVIRONMENT = "shared";
+var SIDE_CONFLICT2 = "test-source-side-conflict";
+var UNREADABLE_TEST = "test-source-unreadable";
+function readTest(root, path, diagnostics) {
+  try {
+    return readFileSync12(resolve20(root, path), "utf8");
+  } catch (error) {
+    diagnostics.push(cliError(UNREADABLE_TEST, `The test file "${path}" could not be read: ${error instanceof Error ? error.message : String(error)}`));
+    return null;
+  }
+}
+function discoverTests(root, sources, excluded = []) {
+  const resolver = createSourceResolver(sources);
+  const tree = listProjectFiles(root, ["."], excluded);
+  const diagnostics = tree.errors.map((message) => cliError(UNREADABLE_TEST, message));
+  const files = [];
+  for (const path of tree.files.filter(isTestPath)) {
+    const resolution = resolver.resolve(path);
+    if (resolution.matches.length > 1) {
+      diagnostics.push(cliError(SIDE_CONFLICT2, `"${path}" is matched by more than one side: ${describeMatches(resolution.matches)}. Narrow the patterns.`));
+      continue;
+    }
+    const source = readTest(root, path, diagnostics);
+    if (source !== null) {
+      files.push({ path, source, environment: resolution.environment ?? DEFAULT_TEST_ENVIRONMENT });
+    }
+  }
+  return { files: files.sort((left, right) => left.path.localeCompare(right.path)), diagnostics };
+}
+
+// src/testing/test-runner.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync8 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname as dirname7, join as join6 } from "node:path";
+
+// src/testing/harness-assertions.ts
+var ASSERTIONS_SOURCE = String.raw`local SENTINEL = '##luam:test'
+local HARNESS = debug.getinfo(1, 'S').short_src
+
+local tests = {}
+local groups = {}
+local beforeHooks = {}
+local afterHooks = {}
+local callLog = {}
+local behaviour = {}
+local stubNames = rawget(_G, '__luamTestNames') or {}
+
+local function escape(value)
+    local text = tostring(value)
+    text = text:gsub('\\', '\\\\')
+    text = text:gsub('\t', '\\t')
+    text = text:gsub('\r', '\\r')
+    text = text:gsub('\n', '\\n')
+    return text
+end
+
+local function emit(kind, ...)
+    local parts = { SENTINEL, kind }
+    for index = 1, select('#', ...) do
+        parts[#parts + 1] = escape(select(index, ...))
+    end
+    io.write(table.concat(parts, '\t'))
+    io.write('\n')
+    io.stdout:flush()
+end
+
+local function origin()
+    local index = 1
+    while true do
+        local info = debug.getinfo(index, 'Sl')
+        if info == nil then
+            return '', ''
+        end
+        if info.what ~= 'C' and info.short_src ~= HARNESS then
+            return info.short_src, info.currentline
+        end
+        index = index + 1
+    end
+end
+
+local function failure(message)
+    local file, line = origin()
+    return { luamTestFailure = true, message = message, file = file, line = line }
+end
+
+local function fail(message)
+    error(failure(message), 0)
+end
+
+local function handler(err)
+    if type(err) == 'table' and err.luamTestFailure then
+        return err
+    end
+    return failure(tostring(err))
+end
+
+local function attempt(body)
+    local ok, err = xpcall(body, handler)
+    if ok then
+        return nil
+    end
+    return err
+end
+
+local function describeValue(value)
+    if type(value) == 'string' then
+        return string.format('%q', value)
+    end
+    return tostring(value)
+end
+
+local function deepEqual(left, right)
+    if left == right then
+        return true
+    end
+    if type(left) ~= 'table' or type(right) ~= 'table' then
+        return false
+    end
+    for key, value in pairs(left) do
+        if not deepEqual(value, right[key]) then
+            return false
+        end
+    end
+    for key in pairs(right) do
+        if left[key] == nil then
+            return false
+        end
+    end
+    return true
+end
+
+local function expect(value)
+    local matchers = {}
+
+    function matchers.toBe(expected)
+        if value ~= expected then
+            fail('expected ' .. describeValue(expected) .. ', got ' .. describeValue(value))
+        end
+    end
+
+    function matchers.toNotBe(expected)
+        if value == expected then
+            fail('expected a value other than ' .. describeValue(expected))
+        end
+    end
+
+    function matchers.toEqual(expected)
+        if not deepEqual(value, expected) then
+            fail('expected ' .. describeValue(expected) .. ', got ' .. describeValue(value))
+        end
+    end
+
+    function matchers.toNotEqual(expected)
+        if deepEqual(value, expected) then
+            fail('expected a value other than ' .. describeValue(expected))
+        end
+    end
+
+    function matchers.toBeNil()
+        if value ~= nil then
+            fail('expected nil, got ' .. describeValue(value))
+        end
+    end
+
+    function matchers.toBeTruthy()
+        if not value then
+            fail('expected a truthy value, got ' .. describeValue(value))
+        end
+    end
+
+    function matchers.toBeFalsy()
+        if value then
+            fail('expected a falsy value, got ' .. describeValue(value))
+        end
+    end
+
+    function matchers.toContain(entry)
+        if type(value) == 'string' then
+            if string.find(value, tostring(entry), 1, true) == nil then
+                fail('expected ' .. describeValue(value) .. ' to contain ' .. describeValue(entry))
+            end
+            return
+        end
+        if type(value) ~= 'table' then
+            fail('expected a string or a table, got ' .. type(value))
+            return
+        end
+        for _, candidate in pairs(value) do
+            if deepEqual(candidate, entry) then
+                return
+            end
+        end
+        fail('expected the table to contain ' .. describeValue(entry))
+    end
+
+    function matchers.toThrow(message)
+        if type(value) ~= 'function' then
+            fail('expected a function, got ' .. type(value))
+            return
+        end
+        local ok, err = pcall(value)
+        if ok then
+            fail('expected the function to throw')
+            return
+        end
+        if message ~= nil and string.find(tostring(err), message, 1, true) == nil then
+            fail('expected the error to contain ' .. describeValue(message) .. ', got ' .. describeValue(tostring(err)))
+        end
+    end
+
+    return matchers
+end
+`;
+
+// src/testing/harness-runner.ts
+var RUNNER_SOURCE = String.raw`local function fullName(name)
+    if #groups == 0 then
+        return name
+    end
+    return table.concat(groups, ' > ') .. ' > ' .. name
+end
+
+local function snapshot(list)
+    local copy = {}
+    for index = 1, #list do
+        copy[index] = list[index]
+    end
+    return copy
+end
+
+local function describe(name, body)
+    groups[#groups + 1] = name
+    local beforeDepth = #beforeHooks
+    local afterDepth = #afterHooks
+    body()
+    for index = #beforeHooks, beforeDepth + 1, -1 do
+        beforeHooks[index] = nil
+    end
+    for index = #afterHooks, afterDepth + 1, -1 do
+        afterHooks[index] = nil
+    end
+    groups[#groups] = nil
+end
+
+local function test(name, body)
+    tests[#tests + 1] = { name = fullName(name), body = body, before = snapshot(beforeHooks), after = snapshot(afterHooks) }
+end
+
+local function beforeEach(body)
+    beforeHooks[#beforeHooks + 1] = body
+end
+
+local function afterEach(body)
+    afterHooks[#afterHooks + 1] = body
+end
+
+local function resetStubs()
+    callLog = {}
+    behaviour = {}
+end
+
+local function record(name, ...)
+    local entries = callLog[name]
+    if entries == nil then
+        entries = {}
+        callLog[name] = entries
+    end
+    entries[#entries + 1] = { n = select('#', ...), ... }
+end
+
+local function makeStub(name)
+    return function(...)
+        record(name, ...)
+        local configured = behaviour[name]
+        if configured == nil then
+            return nil
+        end
+        if configured.kind == 'function' then
+            return configured.body(...)
+        end
+        return configured.value
+    end
+end
+
+local mta = {}
+
+function mta.stub(name, implementation)
+    behaviour[name] = { kind = 'function', body = implementation }
+end
+
+function mta.returns(name, value)
+    behaviour[name] = { kind = 'value', value = value }
+end
+
+function mta.calls(name)
+    return callLog[name] or {}
+end
+
+function mta.reset()
+    resetStubs()
+end
+
+local function runAll()
+    local passed = 0
+    local failed = 0
+    for _, entry in ipairs(tests) do
+        resetStubs()
+        local result = nil
+        for _, hook in ipairs(entry.before) do
+            if result == nil then
+                result = attempt(hook)
+            end
+        end
+        if result == nil then
+            result = attempt(entry.body)
+        end
+        for _, hook in ipairs(entry.after) do
+            local hookResult = attempt(hook)
+            if result == nil then
+                result = hookResult
+            end
+        end
+        if result == nil then
+            passed = passed + 1
+            emit('pass', entry.name)
+        else
+            failed = failed + 1
+            emit('fail', entry.name, result.file, result.line, result.message)
+        end
+    end
+    emit('done', passed, failed)
+    return failed
+end
+
+rawset(_G, 'describe', describe)
+rawset(_G, 'test', test)
+rawset(_G, 'beforeEach', beforeEach)
+rawset(_G, 'afterEach', afterEach)
+rawset(_G, 'expect', expect)
+rawset(_G, 'mta', mta)
+
+setmetatable(_G, {
+    __index = function(_, key)
+        if stubNames[key] == nil then
+            return nil
+        end
+        local stub = makeStub(key)
+        rawset(_G, key, stub)
+        return stub
+    end,
+})
+
+rawset(_G, '__luamTest', {
+    discard = function()
+        tests = {}
+        groups = {}
+        beforeHooks = {}
+        afterHooks = {}
+    end,
+    run = runAll,
+})
+`;
+
+// src/testing/harness-source.ts
+var HARNESS_FILE = "harness.lua";
+var ENTRY_PREFIX = "main-";
+var SENTINEL = "##luam:test";
+var HARNESS_SOURCE = `${ASSERTIONS_SOURCE}
+${RUNNER_SOURCE}`;
+function entryFile(environment) {
+  return `${ENTRY_PREFIX}${environment}.lua`;
+}
+function stubbedGlobals(environment) {
+  return globalsFor(environment).filter((declaration) => declaration.source === "mta" && declaration.type.kind === "function").map((declaration) => declaration.name).sort();
+}
+function entrySource(environment, preload, target) {
+  const names = stubbedGlobals(environment).map((name) => `    ['${name}'] = true,`);
+  const discard = preload.length === 0 ? [] : ["__luamTest.discard()"];
+  const lines = [
+    "__luamTestNames = {",
+    ...names,
+    "}",
+    `dofile('${HARNESS_FILE}')`,
+    ...preload.map((path) => `dofile('${path}')`),
+    ...discard,
+    ...target.map((path) => `dofile('${path}')`),
+    "local failed = __luamTest.run()",
+    "os.exit(failed == 0 and 0 or 1)"
+  ];
+  return `${lines.join("\n")}
+`;
+}
+
+// src/testing/test-runner.ts
+function runLua(executable, args, cwd) {
+  const result = spawnSync3(executable, [...args], { cwd, encoding: "utf8", shell: false, windowsHide: true });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    failure: result.error === void 0 ? null : result.error.message
+  };
+}
+function unescape(value) {
+  return value.replace(/\\(.)/g, (match, character) => {
+    if (character === "n") {
+      return "\n";
+    }
+    if (character === "r") {
+      return "\r";
+    }
+    return character === "t" ? "	" : character;
+  });
+}
+function parseLine(environment, line2) {
+  const parts = line2.split("	");
+  if (parts[0] !== SENTINEL || parts[1] !== "pass" && parts[1] !== "fail") {
+    return null;
+  }
+  const passed = parts[1] === "pass";
+  const file = unescape(parts[3] ?? "");
+  const parsedLine = Number(parts[4] ?? "");
+  return {
+    environment,
+    name: unescape(parts[2] ?? ""),
+    passed,
+    file: file.length === 0 ? null : file,
+    line: Number.isSafeInteger(parsedLine) && parsedLine > 0 ? parsedLine : null,
+    message: unescape(parts[5] ?? "")
+  };
+}
+function parseRunOutput(environment, stdout) {
+  const results = [];
+  const output = [];
+  for (const line2 of stdout.split(/\r?\n/)) {
+    const result = parseLine(environment, line2);
+    if (result !== null) {
+      results.push(result);
+      continue;
+    }
+    if (line2.startsWith(SENTINEL) || line2.length === 0) {
+      continue;
+    }
+    output.push(line2);
+  }
+  return { results, output };
+}
+function writeWorkspace(directory, scripts) {
+  writeFileSync8(join6(directory, HARNESS_FILE), HARNESS_SOURCE, "utf8");
+  for (const script of scripts) {
+    const target = join6(directory, script.path);
+    mkdirSync7(dirname7(target), { recursive: true });
+    writeFileSync8(target, script.content, "utf8");
+  }
+}
+function loadOrder(available, environment) {
+  const shared = bundlePath("shared");
+  const own = bundlePath(environment);
+  const target = available.has(own) ? [own] : [];
+  if (environment === "shared") {
+    return { preload: [], target };
+  }
+  return { preload: available.has(shared) ? [shared] : [], target };
+}
+function runTests(request) {
+  const spawn2 = request.spawn ?? runLua;
+  const directory = mkdtempSync2(join6(tmpdir2(), "luam-test-"));
+  const available = new Set(request.scripts.map((script) => script.path));
+  try {
+    writeWorkspace(directory, request.scripts);
+    return ALL_ENVIRONMENTS.filter((environment) => request.environments.includes(environment)).map((environment) => {
+      const { preload, target } = loadOrder(available, environment);
+      const entry = entryFile(environment);
+      writeFileSync8(join6(directory, entry), entrySource(environment, preload, target), "utf8");
+      const execution = spawn2(request.executable, [entry], directory);
+      const parsed = parseRunOutput(environment, execution.stdout);
+      const failure3 = execution.failure ?? (parsed.results.length === 0 && execution.stderr.length > 0 ? execution.stderr.trim() : null);
+      return { environment, results: parsed.results, output: parsed.output, failure: failure3 };
+    });
+  } finally {
+    rmSync2(directory, { recursive: true, force: true });
+  }
+}
+
+// src/commands/test-command.ts
+function testEnvironments(build, paths) {
+  const found = build.bundles.flatMap(
+    (bundle) => bundle.members.flatMap((member) => member.kind === "module" && paths.has(member.module.source) ? [member.module.environment] : [])
+  );
+  return [...new Set(found)];
+}
+function runTestCommand(context, options = {}) {
+  const reporter = commandReporter(context);
+  const excluded = [context.config.outDir, context.config.contracts];
+  const discovered = discoverTests(context.root, context.config.sources, excluded);
+  reportCliDiagnostics(reporter, discovered.diagnostics);
+  if (hasCliErrors(discovered.diagnostics)) {
+    return EXIT_DIAGNOSTICS;
+  }
+  if (discovered.files.length === 0) {
+    reporter.warn(`No "${TEST_EXTENSION}" files were found. Write one next to the module it covers.`);
+    return EXIT_OK;
+  }
+  const request = { explicit: options.lua ?? null, env: options.env ?? null, ...options.probe === void 0 ? {} : { probe: options.probe } };
+  const interpreter = findLuaInterpreter(request);
+  if (interpreter === null) {
+    reporter.error(describeMissingInterpreter(request));
+    reporter.detail(INSTALL_HINT);
+    return EXIT_USAGE;
+  }
+  const started = performance.now();
+  const outcome = runCompile(context.root, context.config, { additionalFiles: discovered.files, development: true, layout: "bundle", map: true });
+  reportCliDiagnostics(reporter, outcome.diagnostics);
+  reportFileDiagnostics(reporter, outcome.fileDiagnostics, outcome.sources);
+  if (outcome.build === null) {
+    reporter.error("Tests failed: the project did not compile.");
+    return EXIT_DIAGNOSTICS;
+  }
+  const paths = new Set(discovered.files.map((file) => file.path));
+  const environments = testEnvironments(outcome.build, paths);
+  const runs = runTests({
+    executable: interpreter.executable,
+    scripts: outcome.build.scripts,
+    environments,
+    ...options.spawn === void 0 ? {} : { spawn: options.spawn }
+  });
+  return reportTestResults(reporter, runs, context.root, outcome.map, performance.now() - started) ? EXIT_OK : EXIT_DIAGNOSTICS;
+}
+
+// src/cli/registry/test-registration.ts
+function registerTestCommand(program2, runtime) {
+  const command = program2.command("test").description("Compile the project with its test files and run them on a Lua 5.1 interpreter.");
+  addProjectOptions(command);
+  command.option("--lua <path>", "Path to the Lua 5.1 interpreter that runs the tests.");
+  command.action((options) => {
+    const project = createProjectContext(runtime, "test", options);
+    if (project.context === null) {
+      runtime.exitCode = project.error;
+      return;
+    }
+    runtime.exitCode = runTestCommand(project.context, { lua: options.lua ?? null, env: runtime.env[LUA_ENV_VARIABLE] ?? null });
+  });
+}
+
 // src/commands/trace-command.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "node:fs";
 function defaultMapPath(root, options, reporter) {
   const loaded = loadManifest(root, { path: options.manifestPath, mode: manifestMode("trace"), env: options.env });
   if (loaded.config !== null) {
@@ -24591,7 +25305,7 @@ function readStandardInput() {
     return "";
   }
   try {
-    return readFileSync11(0, "utf8");
+    return readFileSync13(0, "utf8");
   } catch {
     return "";
   }
@@ -24676,6 +25390,7 @@ var COMMAND_REGISTRARS = [
   registerInitCommand,
   registerServerCommand,
   registerSetupCommand,
+  registerTestCommand,
   registerTraceCommand
 ];
 

package/package.json

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