@xnoxs/flux-lang 3.1.1

package/src/self/stdlib.js

@@ -0,0 +1,396 @@
+// ── Flux stdlib ──
+
+function map(arr, fn) { return arr.map(fn); }
+
+function filter(arr, fn) { return arr.filter(fn); }
+
+function reduce(arr, fn, init) { return arguments.length >= 3 ? arr.reduce(fn, init) : arr.reduce(fn); }
+
+function forEach(arr, fn) { arr.forEach(fn); return arr; }
+
+function find(arr, fn) { return arr.find(fn); }
+
+function findIndex(arr, fn) { return arr.findIndex(fn); }
+
+function some(arr, fn) { return arr.some(fn); }
+
+function every(arr, fn) { return arr.every(fn); }
+
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+
+function sort(arr, fn) { return arr.slice().sort(fn); }
+
+function flat(arr, depth) { return arr.flat(depth != null ? depth : 1); }
+
+function flatMap(arr, fn) { return arr.flatMap(fn); }
+
+function includes(arr, val) { return arr.includes(val); }
+
+function range(start, end, step) {
+  if (arguments.length === 1) { end = start; start = 0; }
+  step = step || (end >= start ? 1 : -1);
+  const out = [];
+  if (step > 0) { for (let i = start; i < end; i += step) out.push(i); }
+  else          { for (let i = start; i > end; i += step) out.push(i); }
+  return out;
+}
+
+function zip() {
+  const arrays = Array.from(arguments);
+  const len = Math.min.apply(null, arrays.map(function(a) { return a.length; }));
+  const out = [];
+  for (let i = 0; i < len; i++) out.push(arrays.map(function(a) { return a[i]; }));
+  return out;
+}
+
+function enumerate(arr, start) {
+  start = start || 0;
+  return arr.map(function(v, i) { return [i + start, v]; });
+}
+
+function flatten(arr, depth) {
+  return depth == null ? arr.flat(Infinity) : arr.flat(depth);
+}
+
+function chunk(arr, size) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+}
+
+function unique(arr) {
+  return Array.from(new Set(arr));
+}
+
+function groupBy(arr, fn) {
+  return arr.reduce(function(acc, v) {
+    var k = typeof fn === 'function' ? fn(v) : v[fn];
+    (acc[k] = acc[k] || []).push(v);
+    return acc;
+  }, {});
+}
+
+function sortBy(arr, fn) {
+  return arr.slice().sort(function(a, b) {
+    var ka = typeof fn === 'function' ? fn(a) : a[fn];
+    var kb = typeof fn === 'function' ? fn(b) : b[fn];
+    return ka < kb ? -1 : ka > kb ? 1 : 0;
+  });
+}
+
+function clamp(val, min, max) {
+  return Math.min(Math.max(val, min), max);
+}
+
+function sum(arr) {
+  return arr.reduce(function(a, b) { return a + b; }, 0);
+}
+
+function product(arr) {
+  return arr.reduce(function(a, b) { return a * b; }, 1);
+}
+
+function randInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function sample(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function shuffle(arr) {
+  var a = arr.slice();
+  for (var i = a.length - 1; i > 0; i--) {
+    var j = Math.floor(Math.random() * (i + 1));
+    var tmp = a[i]; a[i] = a[j]; a[j] = tmp;
+  }
+  return a;
+}
+
+function pick(obj, keys) {
+  var out = {};
+  keys.forEach(function(k) { if (Object.prototype.hasOwnProperty.call(obj, k)) out[k] = obj[k]; });
+  return out;
+}
+
+function omit(obj, keys) {
+  var ks = new Set(keys);
+  var out = {};
+  Object.keys(obj).forEach(function(k) { if (!ks.has(k)) out[k] = obj[k]; });
+  return out;
+}
+
+function mapValues(obj, fn) {
+  var out = {};
+  Object.keys(obj).forEach(function(k) { out[k] = fn(obj[k], k); });
+  return out;
+}
+
+function filterValues(obj, fn) {
+  var out = {};
+  Object.keys(obj).forEach(function(k) { if (fn(obj[k], k)) out[k] = obj[k]; });
+  return out;
+}
+
+function fromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+function deepClone(v) {
+  return JSON.parse(JSON.stringify(v));
+}
+
+function sleep(ms) {
+  return new Promise(function(resolve) { setTimeout(resolve, ms); });
+}
+
+async function retry(fn, attempts, delay) {
+  attempts = attempts || 3;
+  delay    = delay    || 300;
+  for (var i = 0; i < attempts; i++) {
+    try { return await fn(); } catch(e) {
+      if (i === attempts - 1) throw e;
+      await sleep(delay * Math.pow(2, i));
+    }
+  }
+}
+
+function memoize(fn) {
+  var cache = new Map();
+  return function() {
+    var key = JSON.stringify(arguments);
+    if (cache.has(key)) return cache.get(key);
+    var result = fn.apply(this, arguments);
+    cache.set(key, result);
+    return result;
+  };
+}
+
+function pipe() {
+  var fns = Array.from(arguments);
+  return function(x) { return fns.reduce(function(v, f) { return f(v); }, x); };
+}
+
+function compose() {
+  var fns = Array.from(arguments);
+  return function(x) { return fns.reduceRight(function(v, f) { return f(v); }, x); };
+}
+
+function partial(fn) {
+  var args = Array.from(arguments).slice(1);
+  return function() { return fn.apply(this, args.concat(Array.from(arguments))); };
+}
+
+function curry(fn) {
+  return function curried() {
+    var args = Array.from(arguments);
+    if (args.length >= fn.length) return fn.apply(this, args);
+    return function() { return curried.apply(this, args.concat(Array.from(arguments))); };
+  };
+}
+
+function capitalize(s) {
+  return s ? s[0].toUpperCase() + s.slice(1) : s;
+}
+
+function camelCase(s) {
+  return s.replace(/[-_\s]+(.)/g, function(_, c) { return c.toUpperCase(); }).replace(/^./, function(c) { return c.toLowerCase(); });
+}
+
+function snakeCase(s) {
+  return s.replace(/([A-Z])/g, function(c) { return '_' + c.toLowerCase(); }).replace(/[-\s]+/g, '_').replace(/^_/, '');
+}
+
+function kebabCase(s) {
+  return s.replace(/([A-Z])/g, function(c) { return '-' + c.toLowerCase(); }).replace(/[_\s]+/g, '-').replace(/^-/, '');
+}
+
+function truncate(s, len, suffix) {
+  suffix = suffix != null ? suffix : '...';
+  if (s.length <= len) return s;
+  // FIX: guard against suffix longer than len to avoid negative slice index
+  var cut = len - suffix.length;
+  if (cut <= 0) return suffix.slice(0, len);
+  return s.slice(0, cut) + suffix;
+}
+
+function pad(s, len, char) {
+  char = char || ' ';
+  s = String(s);
+  var total = len - s.length;
+  if (total <= 0) return s;
+  var half = Math.floor(total / 2);
+  return char.repeat(half) + s + char.repeat(total - half);
+}
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.1.0
+"use strict";
+
+const STDLIB_SYMBOLS = ["range", "zip", "enumerate", "clamp", "sum", "product", "flatten", "chunk", "unique", "groupBy", "sortBy", "pick", "omit", "deepEqual", "deepClone", "sleep", "retry", "memoize", "pipe", "compose", "partial", "curry", "capitalize", "camelCase", "snakeCase", "kebabCase", "truncate", "pad", "randInt", "sample", "shuffle", "mapValues", "filterValues", "fromEntries", "map", "filter", "reduce", "forEach", "find", "findIndex", "some", "every", "join", "sort", "flat", "flatMap", "includes"];
+module.exports.STDLIB_SYMBOLS = STDLIB_SYMBOLS;
+function makeSymbolRe(sym) {
+  return new RegExp((("\\b" + sym) + "\\s*\\("), "g");
+}
+function detectUsedSymbols(jsCode) {
+  return STDLIB_SYMBOLS.filter((sym) => makeSymbolRe(sym).test(jsCode));
+}
+module.exports.detectUsedSymbols = detectUsedSymbols;
+function buildStdlib(symbols) {
+  let needed = new Set(STDLIB_SYMBOLS);
+  if (symbols) {
+    needed = new Set(symbols.filter((s) => STDLIB_SYMBOLS.includes(s)));
+  }
+  if ((needed.size == 0)) {
+    return "";
+  }
+  const parts = ["// ── Flux stdlib ──"];
+  if (needed.has("map")) {
+    parts.push("function map(arr, fn) { return arr.map(fn); }");
+  }
+  if (needed.has("filter")) {
+    parts.push("function filter(arr, fn) { return arr.filter(fn); }");
+  }
+  if (needed.has("reduce")) {
+    parts.push("function reduce(arr, fn, init) { return arguments.length >= 3 ? arr.reduce(fn, init) : arr.reduce(fn); }");
+  }
+  if (needed.has("forEach")) {
+    parts.push("function forEach(arr, fn) { arr.forEach(fn); return arr; }");
+  }
+  if (needed.has("find")) {
+    parts.push("function find(arr, fn) { return arr.find(fn); }");
+  }
+  if (needed.has("findIndex")) {
+    parts.push("function findIndex(arr, fn) { return arr.findIndex(fn); }");
+  }
+  if (needed.has("some")) {
+    parts.push("function some(arr, fn) { return arr.some(fn); }");
+  }
+  if (needed.has("every")) {
+    parts.push("function every(arr, fn) { return arr.every(fn); }");
+  }
+  if (needed.has("join")) {
+    parts.push("function join(arr, sep) { return arr.join(sep != null ? sep : ','); }");
+  }
+  if (needed.has("sort")) {
+    parts.push("function sort(arr, fn) { return arr.slice().sort(fn); }");
+  }
+  if (needed.has("flat")) {
+    parts.push("function flat(arr, depth) { return arr.flat(depth != null ? depth : 1); }");
+  }
+  if (needed.has("flatMap")) {
+    parts.push("function flatMap(arr, fn) { return arr.flatMap(fn); }");
+  }
+  if (needed.has("includes")) {
+    parts.push("function includes(arr, val) { return arr.includes(val); }");
+  }
+  if (needed.has("range")) {
+    parts.push("function range(start, end, step) {\n  if (arguments.length === 1) { end = start; start = 0; }\n  step = step || (end >= start ? 1 : -1);\n  const out = [];\n  if (step > 0) { for (let i = start; i < end; i += step) out.push(i); }\n  else          { for (let i = start; i > end; i += step) out.push(i); }\n  return out;\n}");
+  }
+  if (needed.has("zip")) {
+    parts.push("function zip() {\n  const arrays = Array.from(arguments);\n  const len = Math.min.apply(null, arrays.map(function(a) { return a.length; }));\n  const out = [];\n  for (let i = 0; i < len; i++) out.push(arrays.map(function(a) { return a[i]; }));\n  return out;\n}");
+  }
+  if (needed.has("enumerate")) {
+    parts.push("function enumerate(arr, start) {\n  start = start || 0;\n  return arr.map(function(v, i) { return [i + start, v]; });\n}");
+  }
+  if (needed.has("flatten")) {
+    parts.push("function flatten(arr, depth) {\n  return depth == null ? arr.flat(Infinity) : arr.flat(depth);\n}");
+  }
+  if (needed.has("chunk")) {
+    parts.push("function chunk(arr, size) {\n  const out = [];\n  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));\n  return out;\n}");
+  }
+  if (needed.has("unique")) {
+    parts.push("function unique(arr) {\n  return Array.from(new Set(arr));\n}");
+  }
+  if (needed.has("groupBy")) {
+    parts.push("function groupBy(arr, fn) {\n  return arr.reduce(function(acc, v) {\n    var k = typeof fn === 'function' ? fn(v) : v[fn];\n    (acc[k] = acc[k] || []).push(v);\n    return acc;\n  }, {});\n}");
+  }
+  if (needed.has("sortBy")) {
+    parts.push("function sortBy(arr, fn) {\n  return arr.slice().sort(function(a, b) {\n    var ka = typeof fn === 'function' ? fn(a) : a[fn];\n    var kb = typeof fn === 'function' ? fn(b) : b[fn];\n    return ka < kb ? -1 : ka > kb ? 1 : 0;\n  });\n}");
+  }
+  if (needed.has("clamp")) {
+    parts.push("function clamp(val, min, max) {\n  return Math.min(Math.max(val, min), max);\n}");
+  }
+  if (needed.has("sum")) {
+    parts.push("function sum(arr) {\n  return arr.reduce(function(a, b) { return a + b; }, 0);\n}");
+  }
+  if (needed.has("product")) {
+    parts.push("function product(arr) {\n  return arr.reduce(function(a, b) { return a * b; }, 1);\n}");
+  }
+  if (needed.has("randInt")) {
+    parts.push("function randInt(min, max) {\n  return Math.floor(Math.random() * (max - min + 1)) + min;\n}");
+  }
+  if (needed.has("sample")) {
+    parts.push("function sample(arr) {\n  return arr[Math.floor(Math.random() * arr.length)];\n}");
+  }
+  if (needed.has("shuffle")) {
+    parts.push("function shuffle(arr) {\n  var a = arr.slice();\n  for (var i = a.length - 1; i > 0; i--) {\n    var j = Math.floor(Math.random() * (i + 1));\n    var tmp = a[i]; a[i] = a[j]; a[j] = tmp;\n  }\n  return a;\n}");
+  }
+  if (needed.has("pick")) {
+    parts.push("function pick(obj, keys) {\n  var out = {};\n  keys.forEach(function(k) { if (Object.prototype.hasOwnProperty.call(obj, k)) out[k] = obj[k]; });\n  return out;\n}");
+  }
+  if (needed.has("omit")) {
+    parts.push("function omit(obj, keys) {\n  var ks = new Set(keys);\n  var out = {};\n  Object.keys(obj).forEach(function(k) { if (!ks.has(k)) out[k] = obj[k]; });\n  return out;\n}");
+  }
+  if (needed.has("mapValues")) {
+    parts.push("function mapValues(obj, fn) {\n  var out = {};\n  Object.keys(obj).forEach(function(k) { out[k] = fn(obj[k], k); });\n  return out;\n}");
+  }
+  if (needed.has("filterValues")) {
+    parts.push("function filterValues(obj, fn) {\n  var out = {};\n  Object.keys(obj).forEach(function(k) { if (fn(obj[k], k)) out[k] = obj[k]; });\n  return out;\n}");
+  }
+  if (needed.has("fromEntries")) {
+    parts.push("function fromEntries(entries) {\n  return Object.fromEntries(entries);\n}");
+  }
+  if (needed.has("deepEqual")) {
+    parts.push("function deepEqual(a, b) {\n  return JSON.stringify(a) === JSON.stringify(b);\n}");
+  }
+  if (needed.has("deepClone")) {
+    parts.push("function deepClone(v) {\n  return JSON.parse(JSON.stringify(v));\n}");
+  }
+  if (needed.has("sleep")) {
+    parts.push("function sleep(ms) {\n  return new Promise(function(resolve) { setTimeout(resolve, ms); });\n}");
+  }
+  if (needed.has("retry")) {
+    parts.push("async function retry(fn, attempts, delay) {\n  attempts = attempts || 3;\n  delay    = delay    || 300;\n  for (var i = 0; i < attempts; i++) {\n    try { return await fn(); } catch(e) {\n      if (i === attempts - 1) throw e;\n      await sleep(delay * Math.pow(2, i));\n    }\n  }\n}");
+  }
+  if (needed.has("memoize")) {
+    parts.push("function memoize(fn) {\n  var cache = new Map();\n  return function() {\n    var key = JSON.stringify(arguments);\n    if (cache.has(key)) return cache.get(key);\n    var result = fn.apply(this, arguments);\n    cache.set(key, result);\n    return result;\n  };\n}");
+  }
+  if (needed.has("pipe")) {
+    parts.push("function pipe() {\n  var fns = Array.from(arguments);\n  return function(x) { return fns.reduce(function(v, f) { return f(v); }, x); };\n}");
+  }
+  if (needed.has("compose")) {
+    parts.push("function compose() {\n  var fns = Array.from(arguments);\n  return function(x) { return fns.reduceRight(function(v, f) { return f(v); }, x); };\n}");
+  }
+  if (needed.has("partial")) {
+    parts.push("function partial(fn) {\n  var args = Array.from(arguments).slice(1);\n  return function() { return fn.apply(this, args.concat(Array.from(arguments))); };\n}");
+  }
+  if (needed.has("curry")) {
+    parts.push("function curry(fn) {\n  return function curried() {\n    var args = Array.from(arguments);\n    if (args.length >= fn.length) return fn.apply(this, args);\n    return function() { return curried.apply(this, args.concat(Array.from(arguments))); };\n  };\n}");
+  }
+  if (needed.has("capitalize")) {
+    parts.push("function capitalize(s) {\n  return s ? s[0].toUpperCase() + s.slice(1) : s;\n}");
+  }
+  if (needed.has("camelCase")) {
+    parts.push("function camelCase(s) {\n  return s.replace(/[-_\\s]+(.)/g, function(_, c) { return c.toUpperCase(); }).replace(/^./, function(c) { return c.toLowerCase(); });\n}");
+  }
+  if (needed.has("snakeCase")) {
+    parts.push("function snakeCase(s) {\n  return s.replace(/([A-Z])/g, function(c) { return '_' + c.toLowerCase(); }).replace(/[-\\s]+/g, '_').replace(/^_/, '');\n}");
+  }
+  if (needed.has("kebabCase")) {
+    parts.push("function kebabCase(s) {\n  return s.replace(/([A-Z])/g, function(c) { return '-' + c.toLowerCase(); }).replace(/[_\\s]+/g, '-').replace(/^-/, '');\n}");
+  }
+  if (needed.has("truncate")) {
+    parts.push("function truncate(s, len, suffix) {\n  suffix = suffix != null ? suffix : '...';\n  if (s.length <= len) return s;\n  var cut = len - suffix.length;\n  if (cut <= 0) return suffix.slice(0, len);\n  return s.slice(0, cut) + suffix;\n}");
+  }
+  if (needed.has("pad")) {
+    parts.push("function pad(s, len, char) {\n  char = char || ' ';\n  s = String(s);\n  var total = len - s.length;\n  if (total <= 0) return s;\n  var half = Math.floor(total / 2);\n  return char.repeat(half) + s + char.repeat(total - half);\n}");
+  }
+  parts.push("// ── end stdlib ──\n");
+  return parts.join("\n");
+}
+module.exports.buildStdlib = buildStdlib;

package/src/self/test-runner.flux

@@ -0,0 +1,201 @@
+// ============================================================
+//  Flux Self-Hosted Test Runner
+//  src/self/test-runner.flux — written in Flux, compiled by stage-0
+//
+//  Discovers and runs Flux test files (*.test.flux)
+//  Test functions must be named test_* (e.g. fn test_arithmetic():)
+//  Globals injected: assert, assertEqual, assertNotEqual,
+//                    assertThrows, assertClose
+// ============================================================
+
+import Fs   from "fs"
+import Path from "path"
+import Os   from "os"
+
+val C = {
+  reset:  '\x1b[0m',
+  bold:   '\x1b[1m',
+  red:    '\x1b[31m',
+  green:  '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan:   '\x1b[36m',
+  gray:   '\x1b[90m',
+  dim:    '\x1b[2m',
+}
+
+fn clr(c, s):
+  return process.env.NO_COLOR ? s : c + s + C.reset
+
+val TEST_HELPERS = `"use strict";
+
+const __results = [];
+let   __current = null;
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'Assertion failed: expected truthy');
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  if (!ok) {
+    throw new Error(
+      message ||
+      'Expected ' + JSON.stringify(expected) + ' but got ' + JSON.stringify(actual)
+    );
+  }
+}
+
+function assertNotEqual(actual, expected, message) {
+  const ok = JSON.stringify(actual) !== JSON.stringify(expected);
+  if (!ok) {
+    throw new Error(message || 'Expected values to be different but both were ' + JSON.stringify(actual));
+  }
+}
+
+function assertThrows(fn, message) {
+  try { fn(); }
+  catch (_) { return; }
+  throw new Error(message || 'Expected function to throw, but it did not');
+}
+
+function assertClose(actual, expected, delta, message) {
+  delta = delta || 1e-9;
+  if (Math.abs(actual - expected) > delta) {
+    throw new Error(message || ('Expected ' + actual + ' to be close to ' + expected + ' (delta=' + delta + ')'));
+  }
+}
+
+function __runTest(name, fn) {
+  try {
+    fn();
+    __results.push({ name: name, ok: true });
+  } catch(e) {
+    __results.push({ name: name, ok: false, error: e.message });
+  }
+}
+`
+
+export fn discoverTestFiles(target):
+  val abs = Path.resolve(target)
+  if not Fs.existsSync(abs):
+    throw new Error("Not found: " + abs)
+  val stat = Fs.statSync(abs)
+  if stat.isDirectory():
+    return Fs.readdirSync(abs)
+      .filter(f -> f.endsWith('.test.flux'))
+      .map(f -> Path.join(abs, f))
+      .sort()
+  if abs.endsWith('.flux'): return [abs]
+  throw new Error("Expected a .flux file or directory, got: " + abs)
+
+export fn runTestFile(filePath, transpile):
+  val source = Fs.readFileSync(filePath, 'utf8')
+  val result = transpile(source)
+
+  if not result.success:
+    return {
+      file:    Path.basename(filePath),
+      errors:  result.errors,
+      tests:   [],
+      compile: false,
+    }
+
+  val fnNames = []
+  val fnRe = /^function (test_[a-zA-Z0-9_]+)\s*\(/mg
+  var m = fnRe.exec(result.output)
+  while m:
+    fnNames.push(m[1])
+    m = fnRe.exec(result.output)
+
+  val runnerParts = [
+    TEST_HELPERS,
+    result.output,
+    '',
+    '// ── auto-generated test runner ──',
+  ]
+  for n in fnNames:
+    runnerParts.push('__runTest(' + JSON.stringify(n.replace(/^test_/, '').replace(/_/g, ' ')) + ', ' + n + ');')
+  runnerParts.push('module.exports = { __results };')
+
+  val runner   = runnerParts.join('\n')
+  val tmpPath  = Path.join(Os.tmpdir(), '_flux_test_' + Date.now() + '.js')
+  try:
+    Fs.writeFileSync(tmpPath, runner, 'utf8')
+    val mod   = require(tmpPath)
+    val tests = (mod and mod.__results) ? mod.__results : []
+    return {
+      file:    Path.basename(filePath),
+      tests,
+      compile: true,
+      errors:  [],
+    }
+  catch(e):
+    return {
+      file:    Path.basename(filePath),
+      tests:   [],
+      compile: false,
+      errors:  [{ message: 'Runtime error: ' + e.message }],
+    }
+  finally:
+    try: Fs.unlinkSync(tmpPath)
+    catch(ignored): null
+
+export fn runTests(target, transpile):
+  var files = []
+  try:
+    files = discoverTestFiles(target)
+  catch(e):
+    console.error(clr(C.red, '✗ ' + e.message))
+    process.exit(1)
+
+  if files.length == 0:
+    console.log(clr(C.yellow, 'No *.test.flux files found in: ' + target))
+    return
+
+  var totalPass  = 0
+  var totalFail  = 0
+  var totalFiles = 0
+  val t0 = Date.now()
+
+  for file in files:
+    totalFiles = totalFiles + 1
+    console.log(clr(C.cyan, '\n◈ ' + Path.basename(file)))
+
+    val result = runTestFile(file, transpile)
+
+    if not result.compile:
+      console.log(clr(C.red, '  ✗ Compile error:'))
+      for e in result.errors:
+        console.log(clr(C.red, '    ' + e.message))
+      totalFail = totalFail + 1
+      continue
+
+    if result.tests.length == 0:
+      console.log(clr(C.yellow, '  (no test_ functions found)'))
+      continue
+
+    for t in result.tests:
+      if t.ok:
+        totalPass = totalPass + 1
+        console.log(clr(C.green, '  ✓') + clr(C.gray, ' ' + t.name))
+      else:
+        totalFail = totalFail + 1
+        console.log(clr(C.red, '  ✗ ' + t.name))
+        console.log(clr(C.dim, '    ' + t.error))
+
+  val elapsed = Date.now() - t0
+  val total   = totalPass + totalFail
+
+  console.log()
+  console.log(clr(C.bold, '─'.repeat(50)))
+  console.log(
+    clr(C.bold, 'Results: ') +
+    clr(C.green, totalPass + ' passed') + clr(C.gray, ', ') +
+    (totalFail > 0 ? clr(C.red, totalFail + ' failed') : clr(C.gray, totalFail + ' failed')) +
+    clr(C.gray, ' (' + total + ' total) in ' + elapsed + 'ms')
+  )
+  console.log()
+
+  if totalFail > 0: process.exitCode = 1