@looop-games/cli 0.1.16 → 0.1.17

package/CHANGELOG.md

@@ -14,6 +14,29 @@ Versions: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.17] - 2026-07-14
+
+### Added
+- **`looop test <pattern>` runs just the tests you name.** While you're iterating
+  on one part of your game, running the *whole* suite every time is most of the
+  wait. `looop test charge` now runs only the files whose name contains `charge`
+  (`charge.smoke.mjs`, `game-charge.test.mjs`) and skips the rest — a focused,
+  fast re-run. Name more than one (`looop test charge aim`) to widen it. It's for
+  the inner loop, not a replacement for the gate: a pattern that matches nothing
+  stops with an error (so a typo can never pass green having run nothing), and you
+  still run the full `looop test` before you call the work done — a change can
+  break a part you didn't touch, and only the whole suite catches that.
+
+### Fixed
+- **`looop test` no longer pins your whole machine while smokes run.** A headless
+  browser has no graphics card, so a 3D game's tests were rendering on the CPU —
+  one test could quietly eat 8+ processor cores and freeze a modest laptop solid.
+  Tests now render on your actual GPU instead, which is what it's for: the same
+  test that hogged 8+ cores now uses a fraction of one, and renders several times
+  faster. Nothing in your game changes, and your tests check exactly what they
+  did before. On a machine with no usable GPU it simply falls back to the old
+  behaviour — never worse. (Set `LOOOP_TEST_NO_GPU=1` to force the old path.)
+
 ## [0.1.16] - 2026-07-13
 
 ### Added

package/bin/looop.mjs

@@ -69,7 +69,9 @@ try {
       await create({ name: rest.find((a) => !a.startsWith('--')) });
       break;
     case 'test': {
-      const { ok } = await testCmd();
+      // Positional args scope the run: `looop test charge` runs only files whose
+      // path contains "charge". Flags are left for future options (e.g. --changed).
+      const { ok } = await testCmd({ patterns: rest.filter((a) => !a.startsWith('--')) });
       process.exit(ok ? 0 : 1);
     }
     case 'lint': {

package/lib/smoke-gpu-preload.mjs

@@ -0,0 +1,75 @@
+// Preloaded before every browser smoke via `node --import`. Its whole job is to
+// make headless Chromium render on the real GPU instead of SwiftShader.
+//
+// Why it matters: a headless browser has no GPU, so WebGL falls back to
+// SwiftShader — software rasterization spread across a thread pool sized to the
+// machine's core count. A single 3D-game smoke can pin 8+ cores that way, which
+// on a modest laptop means a frozen machine, not just a slow test. Rendering on
+// the actual GPU (Metal / D3D / GL, chosen by ANGLE per platform) moves that work
+// off the CPU entirely: measured ~8.5 cores → ~0.1, with pixel-identical output.
+//
+// It runs as a preload so an UNMODIFIED smoke needs no change: it patches the
+// `chromium.launch` of the GAME's own playwright (resolved from cwd, the same
+// instance the smoke imports) to append the flags. Fetch-only smokes that never
+// import playwright, and machines with no usable GPU, both fall through
+// untouched — ANGLE simply falls back to software, so this is never worse than
+// before. Opt out with LOOOP_TEST_NO_GPU=1.
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+export function gpuArgs() {
+  if (process.env.LOOOP_TEST_NO_GPU === '1') return [];
+  return ['--enable-gpu', '--ignore-gpu-blocklist'];
+}
+
+// Append `extra` to whatever args a caller already passed to chromium.launch(),
+// preserving theirs. Idempotent enough for our use: called once per smoke process.
+export function patchLaunch(chromium, extra = gpuArgs()) {
+  if (!chromium || typeof chromium.launch !== 'function' || extra.length === 0) return false;
+  const orig = chromium.launch.bind(chromium);
+  chromium.launch = (opts = {}) => orig({ ...opts, args: [...(opts.args || []), ...extra] });
+  return true;
+}
+
+// Resolve the SAME playwright module object a smoke's `import 'playwright'` gets.
+// The catch: a bare ESM import resolves via the package's "import" export
+// (index.mjs), while createRequire().resolve() returns the "require" main
+// (index.js) — a DIFFERENT module instance. Patching that one would miss, and the
+// smoke would silently fall back to software with no error. So resolve the
+// package dir, then import its ESM entry explicitly.
+//
+// Resolve from the SMOKE FILE's directory first (process.argv[1] under
+// `node --import <preload> <smoke>`), then cwd. A smoke normally runs from its
+// own game folder (cwd == the smoke's dir), but a runner may invoke it from a
+// different working directory — resolving off the smoke's own location makes the
+// same playwright install resolve either way.
+async function loadGamePlaywright() {
+  const bases = [];
+  const smoke = process.argv[1];
+  if (smoke) bases.push(join(dirname(smoke), 'package.json'));
+  bases.push(join(process.cwd(), 'package.json'));
+  let lastErr;
+  for (const base of bases) {
+    try {
+      const require = createRequire(base);
+      const pkgDir = dirname(require.resolve('playwright')); // .../node_modules/playwright
+      const pkg = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8'));
+      const entry = pkg.exports?.['.']?.import ?? pkg.module ?? pkg.main ?? 'index.js';
+      return import(pathToFileURL(join(pkgDir, entry)).href);
+    } catch (e) { lastErr = e; }
+  }
+  throw lastErr;
+}
+
+// Self-execute on preload. Kept in try/catch so a smoke without playwright (a
+// fetch-only boot smoke) or a missing install never turns a preload into a crash.
+if (gpuArgs().length > 0) {
+  try {
+    const pw = await loadGamePlaywright();
+    patchLaunch(pw.chromium ?? pw.default?.chromium);
+  } catch {
+    // No playwright here, or it couldn't be patched — leave the smoke unchanged.
+  }
+}

package/lib/test-cmd.mjs

@@ -57,16 +57,46 @@ async function freeTestPort(base = 8100) {
   throw new Error('no free port triple found for the test dev stack');
 }
 
-export async function testCmd({ cwd = process.cwd(), log = console.log, devFn = dev, lintFn = lintCmd } = {}) {
+// Preload that GPU-offloads each smoke's browser (see smoke-gpu-preload.mjs).
+// A file URL so `node --import` resolves it regardless of the smoke's cwd.
+const SMOKE_PRELOAD = new URL('./smoke-gpu-preload.mjs', import.meta.url).href;
+
+export async function testCmd({ cwd = process.cwd(), log = console.log, devFn = dev, lintFn = lintCmd, runFn = run, patterns = [] } = {}) {
   const project = findProject(cwd);
-  const { unit, smokes } = discoverTestFiles(project.dir);
+  const all = discoverTestFiles(project.dir);
+
+  // Scoped run (`looop test <pattern>…`): keep only files whose path contains a
+  // pattern. The file-naming convention already encodes the aspect
+  // (`charge.smoke.mjs`, `riven-charge.test.mjs`), so a substring on the path
+  // reaches both a unit test and its smoke without any source→test mapping.
+  // This is a PER-STEP speed lever, not the gate — the full suite still runs at
+  // milestone close and before publish (qa.md T3). With no pattern, everything
+  // runs, exactly as before.
+  const scoped = patterns.length > 0;
+  const matches = (f) => patterns.some((p) => relative(project.dir, f).includes(p));
+  const unit = scoped ? all.unit.filter(matches) : all.unit;
+  const smokes = scoped ? all.smokes.filter(matches) : all.smokes;
 
   // Lint FIRST — it needs no servers and no browser, and the defects it catches
   // (a hardcoded multiplayer host, a smoke pointed at the wrong port) are
   // exactly the ones that make the suite below pass while testing nothing.
   // Failing here does not skip the tests: the creator should see everything
   // that is wrong in one run, not peel it one gate at a time.
-  const lint = await lintFn({ cwd: project.dir, log });
+  //
+  // A SCOPED run skips it: lint is the full gate's job and runs at milestone
+  // close with the whole suite — a `looop test <pattern>` is a focused per-step
+  // re-run, not the gate.
+  const lint = scoped ? { ok: true, skipped: true } : await lintFn({ cwd: project.dir, log });
+
+  // A pattern that matches nothing FAILS LOUD. "0 tests, all green" is the exact
+  // false-pass this whole gate exists to prevent — a mistyped scope must never
+  // read as "everything's fine." (A game with genuinely no tests and no pattern
+  // is the legitimately-green fresh-game case below.)
+  if (patterns.length && unit.length + smokes.length === 0) {
+    log(`No tests matched ${patterns.map((p) => `"${p}"`).join(', ')} in ${project.dir}.`);
+    log(`(${all.unit.length + all.smokes.length} test file(s) exist; none contain that pattern. Check the spelling, or run \`looop test\` with no pattern to run the whole suite.)`);
+    return { ok: false, ran: 0, lint };
+  }
 
   if (unit.length + smokes.length === 0) {
     log(`No tests yet in ${project.dir} — nothing to run.`);
@@ -74,6 +104,10 @@ export async function testCmd({ cwd = process.cwd(), log = console.log, devFn =
     return { ok: lint.ok, ran: 0 };
   }
 
+  if (patterns.length) {
+    log(`▶ scoped to ${patterns.map((p) => `"${p}"`).join(', ')}: ${unit.length + smokes.length} of ${all.unit.length + all.smokes.length} file(s) — full suite still runs at milestone close.`);
+  }
+
   let ok = lint.ok;
 
   // If looop test itself runs under a node --test parent, the inherited
@@ -117,7 +151,7 @@ export async function testCmd({ cwd = process.cwd(), log = console.log, devFn =
     try {
       for (const file of smokes) {
         const rel = relative(project.dir, file);
-        const code = await run([file], {
+        const code = await runFn(['--import', SMOKE_PRELOAD, file], {
           cwd: project.dir,
           env: {
             ...env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looop-games/cli",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Looop game development CLI — dev server, login, and publishing for standalone Looop games.",
   "type": "module",
   "license": "Apache-2.0",