@looop-games/cli 0.1.15 → 0.1.17

package/CHANGELOG.md

@@ -14,6 +14,55 @@ 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
+- `looop lane <name>` — open an isolated copy of your game to experiment in. It
+  lives in its own folder, on its own branch, with its own dev stack, so an
+  experiment can't disturb the game you're in the middle of. Whatever you have
+  unsaved stays exactly where it is. Like the winner? Merge it. Don't? Delete
+  the folder. The lane borrows the engine from your main folder rather than
+  downloading it again, so opening one is close to instant. Your agent knows
+  when to offer this — ask it for `/worktree`.
+
+### Fixed
+- **`looop publish` no longer guesses a name inside a lane.** Publishing claims
+  a name permanently, and the name defaults to your folder — so publishing from
+  a lane would have claimed `<game>-<lane>` forever for a throwaway experiment
+  (and, if your `package.json` sets `looop.slug`, would have overwritten your
+  live game with it). From a lane, publish now asks you to say the name out
+  loud: `--slug <name>`. Publishing your actual game is unchanged.
+- **`looop dev` no longer kills a dev server that isn't its own.** It used to
+  take over ports 8000/1999/8788 unconditionally, so a second game — or a lane —
+  would shut down the game you already had running and steal its ports. Now it
+  steps around anything else on those ports and picks the next free set, telling
+  you which it took. Run as many games and lanes at once as you like; they no
+  longer fight. It still reclaims *its own* stale server, so you never end up
+  looking at yesterday's code.
+
 ## [0.1.15] - 2026-07-13
 
 ### Changed

package/bin/looop.mjs

@@ -4,6 +4,7 @@
 // Runs inside a standalone game folder (its own repo). The agent is the
 // primary user: keep output plain, actionable, and machine-legible.
 import { dev } from '../lib/dev.mjs';
+import { lane } from '../lib/lane.mjs';
 import { login, whoami } from '../lib/login.mjs';
 import { publish } from '../lib/publish.mjs';
 import { create } from '../lib/create.mjs';
@@ -26,6 +27,7 @@ const HELP = `looop — build and run Looop games
 Usage:
   looop create <name>        Bootstrap a new game folder (multiplayer works out of the box)
   looop dev [--port <n>]     Run the full dev stack (game + multiplayer + services)
+  looop lane <name>          Open an isolated copy of the game to experiment in, safely
   looop test                 Run the game's tests (*.test.mjs) and smokes (*.smoke.mjs)
   looop lint [--fix]         Check the game against the Looop rules (runs inside 'looop test')
   looop changelog [<v>]      What changed in the engine (default: everything newer than your pin)
@@ -38,7 +40,9 @@ Usage:
   looop help                 This message
 
 The dev stack serves your game at http://localhost:8000/games/<name>/index.html
-with local multiplayer on :1999 and the platform services shim on :8788.
+with local multiplayer on :1999 and the platform services shim on :8788. Run
+several at once (a lane, another game) and each picks its own free ports —
+'looop dev' never disturbs a stack that isn't its own.
 `;
 
 try {
@@ -54,11 +58,20 @@ try {
       // Keep the process alive; servers + children hold the loop open.
       break;
     }
+    case 'lane': {
+      const name = rest.find((a) => !a.startsWith('--'));
+      if (!name) throw new Error('Name the lane: looop lane <name>  (e.g. looop lane judder)');
+      const { dir } = await lane(name);
+      console.log(`\nWork in it:\n  cd ${dir} && npx looop dev\n`);
+      break;
+    }
     case 'create':
       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/dev.mjs

@@ -10,13 +10,13 @@
 import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
+import { join, dirname, basename } from 'node:path';
 import { findProject } from './project.mjs';
 import { ensureEngine } from './engine.mjs';
 import { createStaticServer } from './static-server.mjs';
 import { createLlmShim, DEFAULT_API_BASE } from './llm-shim.mjs';
 import { getToken, getApiBase } from './config.mjs';
-import { portsFor, portInUse, killPort, lanIp } from './ports.mjs';
+import { resolvePorts, portInUse, killPort, lanIp } from './ports.mjs';
 import { assertNoInertOverride, scanPrimitives } from './primitives.mjs';
 import { buildDevRoomServer, DEV_OVERRIDES_DIR } from './room-server.mjs';
 
@@ -52,7 +52,21 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
   // Q4 revision: the engine is not an npm dependency — install/refresh it from
   // the platform's login-gated registry (no-op when the pinned version is in).
   const engine = await ensureEngine(project.dir, { log });
-  const ports = portsFor(port ?? Number(process.env.LOOOP_DEV_PORT ?? 8000));
+
+  // Which ports, and may we take them? An explicit --port is obeyed as given
+  // (takeover included). With no flag we step around anyone else's stack —
+  // another lane, another game, an unrelated app — and only ever reclaim our
+  // OWN stale server. See ports.mjs; this is what makes a lane collision-free
+  // without the creator having to remember a flag.
+  const explicit = port ?? (process.env.LOOOP_DEV_PORT ? Number(process.env.LOOOP_DEV_PORT) : null);
+  const { ports, tookOver, steppedAside } = await resolvePorts({
+    projectDir: project.dir,
+    requested: explicit,
+  });
+  for (const s of steppedAside) {
+    const who = s.projectDir ? `another Looop game (${basename(s.projectDir)})` : 'another app';
+    log(`→ :${s.port}  (held by ${who} — leaving it alone)`);
+  }
   const children = [];
   const servers = [];
 
@@ -89,8 +103,11 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
   };
 
   // ─── static ───
-  if (await portInUse(ports.static)) {
-    log(`→ static      :${ports.static}  (in use — killing to take over)`);
+  // `tookOver` is the ONLY licence to kill: an explicit --port, or our own
+  // stale server on this block. resolvePorts already walked away from
+  // everyone else's, so anything still here is fair game.
+  if (tookOver && (await portInUse(ports.static))) {
+    log(`→ static      :${ports.static}  (our stale server — reclaiming)`);
     await killPort(ports.static);
   }
   // overrides/shared/… : the game's engine modifications mount ahead of the
@@ -108,6 +125,7 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
   const overridesDir = join(project.dir, 'overrides', 'shared');
   const staticServer = createStaticServer({
     slug: project.slug,
+    projectDir: project.dir, // answers /__looop/whoami — see ports.mjs
     mounts: [
       { url: `/games/${project.slug}/`, dir: project.dir },
       { url: '/shared/', dir: generatedOverridesDir },
@@ -124,8 +142,8 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
   if (noMp) {
     log(`→ multiplayer :${ports.mp}  (skipped — NO_MP=1)`);
   } else {
-    if (await portInUse(ports.mp)) {
-      log(`→ multiplayer :${ports.mp}  (in use — killing to take over)`);
+    if (tookOver && (await portInUse(ports.mp))) {
+      log(`→ multiplayer :${ports.mp}  (our stale server — reclaiming)`);
       await killPort(ports.mp);
     }
     const pk = spawn(

package/lib/lane.mjs

@@ -0,0 +1,127 @@
+// `looop lane <name>` — open an isolated lane for an experiment.
+//
+// A lane is this game checked out a second time, in its own folder, on its own
+// branch, with its own dev stack. Work in a lane cannot disturb the main
+// checkout: different files, different branch, different servers, different
+// multiplayer room. Win → merge it. Lose → delete the folder; nothing that
+// mattered was ever touched.
+//
+// This exists because the lane used to be a PROCEDURE — a bash block in the
+// build skill: commit-guard, `git worktree add`, `npm install`, and remember a
+// distinct `--port` or you'd kill the main checkout's servers. Four steps,
+// three of them footguns, one of them slow. Agents read that, priced the
+// ceremony, and skipped isolating altogether — repeatedly. The COST was the
+// bug. A procedure a tool can just perform should never be written down and
+// hoped for.
+//
+// What used to be expensive, and isn't any more:
+//
+//   npm install   → node_modules is CLONED from the main checkout. On APFS
+//                   (macOS) and btrfs/xfs (Linux) that's a copy-on-write
+//                   reflink: effectively instant, near-zero extra disk. The
+//                   engine is already sitting one directory up; resolving it
+//                   again over the network was always silly.
+//   --port 8010   → gone. `looop dev` resolves its own ports now and steps
+//                   around anyone else's stack (ports.mjs). A lane just runs
+//                   `npx looop dev`, like everywhere else.
+import { execFileSync } from 'node:child_process';
+import { cpSync, existsSync, statSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { findProject } from './project.mjs';
+import { runNpm } from './npm.mjs';
+
+const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8' }).trim();
+
+// Is this folder a lane (a linked git worktree) rather than the game itself?
+//
+// Git's own marker, no subprocess: in a linked worktree `.git` is a FILE
+// holding `gitdir: …/.git/worktrees/<name>`; in an ordinary repo it's a
+// directory. A folder with no git at all is not a lane.
+//
+// This matters to `publish`, which is global, permanent and irreversible — see
+// the guard there.
+export function isLane(dir) {
+  try {
+    return statSync(join(dir, '.git')).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// Clone a directory tree as cheaply as the filesystem allows.
+//
+// `cp -c` (macOS) and `cp --reflink=auto` (Linux) ask for copy-on-write: the
+// new tree shares its blocks with the old one until something writes. For a
+// node_modules of tens of thousands of files that is the difference between
+// "instant" and "go and make a coffee". Neither is guaranteed — a non-APFS
+// volume, a filesystem without reflinks — so both fall back to a real copy,
+// which is still local, and still beats a network resolve.
+export function cloneTree(src, dest) {
+  const args =
+    process.platform === 'darwin'
+      ? ['-c', '-R', src, dest] // APFS clonefile
+      : process.platform === 'linux'
+        ? ['-r', '--reflink=auto', src, dest] // btrfs/xfs, degrades to a copy
+        : null;
+  if (args) {
+    try {
+      execFileSync('cp', args, { stdio: 'ignore' });
+      return 'cloned';
+    } catch {
+      // Not a CoW filesystem (or no `cp` worth the name — Windows). Fall through.
+    }
+  }
+  cpSync(src, dest, { recursive: true });
+  return 'copied';
+}
+
+export async function lane(name, { cwd = process.cwd(), log = console.log } = {}) {
+  const project = findProject(cwd);
+  const slug = project.slug;
+  const branch = `lane/${name}`;
+  const dir = resolve(project.dir, '..', `${slug}-${name}`);
+
+  if (existsSync(dir)) {
+    throw new Error(
+      `A lane called "${name}" already exists at ${dir}.\n` +
+        `Work in it (cd ${basename(dir)} && npx looop dev), or remove it first ` +
+        `(git worktree remove ${dir}).`,
+    );
+  }
+
+  // `git worktree add` on a repo with NO commits silently produces an empty
+  // orphan lane — the folder exists, the game isn't in it. To a creator that
+  // reads as "the tool deleted my game". Save first, but ONLY in that case:
+  // committing on someone's behalf when they didn't ask is its own betrayal.
+  let savedFirst = false;
+  try {
+    git(project.dir, 'rev-parse', 'HEAD');
+  } catch {
+    log('→ saving your game first (a lane needs at least one save to branch from)');
+    git(project.dir, 'add', '-A');
+    git(project.dir, 'commit', '-m', 'save: initial');
+    savedFirst = true;
+  }
+
+  // Their uncommitted work is deliberately NOT carried across: the lane starts
+  // from the last save. That IS the isolation — the whole point is that what
+  // they're in the middle of stays exactly where it is, untouched.
+  git(project.dir, 'worktree', 'add', '-b', branch, dir);
+  log(`→ lane        ${dir}  (branch ${branch})`);
+
+  // node_modules is gitignored, so the lane arrives empty. Without it, `npx
+  // looop` falls through to a WRONG public package on npm and dies with an
+  // error that reads like a bug in the creator's game.
+  const src = join(project.dir, 'node_modules');
+  let installed = false;
+  if (existsSync(src)) {
+    const how = cloneTree(src, join(dir, 'node_modules'));
+    log(`→ engine      ${how} from the main checkout (no npm install needed)`);
+  } else {
+    log('→ engine      installing (the main checkout has no node_modules to clone)');
+    runNpm(['install'], { cwd: dir, stdio: 'inherit' });
+    installed = true;
+  }
+
+  return { dir, branch, savedFirst, installed };
+}

package/lib/ports.mjs

@@ -8,6 +8,25 @@
 // Takeover: `looop dev` must "just work" — a stale dev session or orphaned
 // workerd holding a port means the user gets stale code with no recourse, so
 // we TERM (then KILL) the listener instead of skipping, exactly like dev.sh.
+//
+// …but ONLY our own. Takeover used to be unconditional: `portInUse()` is a bare
+// TCP connect, so dev killed whatever answered without asking whose it was. In
+// a worktree lane that meant a plain `npx looop dev` SIGKILLed the MAIN
+// checkout's whole stack (game + multiplayer + services) and stole its ports —
+// the tool manufacturing the exact collision a lane exists to prevent, with a
+// remembered `--port 8010` as the only defence. Isolation you have to remember
+// isn't isolation.
+//
+// So a port now has an OWNER, and the answer decides:
+//
+//   free                        → take it
+//   our own dev server          → take it OVER (the stale-code case above)
+//   another project's, or a
+//   foreign app's               → LEAVE IT and step to the next block
+//
+// Ownership is asked, not inferred: the static server answers `/__looop/whoami`
+// with its project dir (static-server.mjs). No registry file to go stale, and
+// nothing to clean up after a crash — if it answers, it's alive.
 import { execFileSync } from 'node:child_process';
 import net from 'node:net';
 import { networkInterfaces } from 'node:os';
@@ -16,11 +35,90 @@ export const STATIC_PORT_BASE = 8000;
 export const MP_PORT_BASE = 1999;
 export const SHIM_PORT_BASE = 8788;
 
+// Ports move in BLOCKS: the browser derives mp/shim from location.port, so the
+// whole stack shifts together. 8000/1999/8788 → 8010/2009/8798 → …
+export const BLOCK_STRIDE = 10;
+export const WHOAMI_PATH = '/__looop/whoami';
+
 export function portsFor(staticPort = STATIC_PORT_BASE) {
   const offset = staticPort - STATIC_PORT_BASE;
   return { static: staticPort, mp: MP_PORT_BASE + offset, shim: SHIM_PORT_BASE + offset };
 }
 
+// Who is on this port? → { projectDir, pid } if one of our dev servers answers,
+// null if the port is silent, or if something that isn't us holds it (a foreign
+// app owes us no answer — and either way the verdict is "not mine, don't touch").
+export function whoIsOn(port, timeoutMs = 400) {
+  return new Promise((resolve) => {
+    const req = net.connect({ port, host: '127.0.0.1' });
+    let body = '';
+    const done = (v) => {
+      req.destroy();
+      resolve(v);
+    };
+    req.setTimeout(timeoutMs, () => done(null));
+    req.on('error', () => done(null)); // nothing listening
+    req.on('connect', () => {
+      req.write(`GET ${WHOAMI_PATH} HTTP/1.0\r\nHost: 127.0.0.1\r\n\r\n`);
+    });
+    req.on('data', (chunk) => {
+      body += chunk;
+      const i = body.indexOf('\r\n\r\n');
+      if (i === -1) return; // headers still arriving
+      if (!/^HTTP\/1\.[01] 200/.test(body)) return done(null); // answered, but not ours
+      try {
+        const parsed = JSON.parse(body.slice(i + 4));
+        done(parsed.projectDir ? parsed : null);
+      } catch {
+        /* body may still be arriving; wait for more, or for the timeout */
+      }
+    });
+    req.on('end', () => done(null));
+  });
+}
+
+// Pick the port block this dev stack should bind.
+//
+// `requested` (an explicit --port) is obeyed as given, takeover included: you
+// named the port, you get the port. Explicit beats clever — it's the AUTO path
+// that has to be safe, because that's the one nobody thought about.
+// `base` exists so the tests can run in a private port range: a suite that
+// probes :8000 for real would fight (and report on) whatever dev servers the
+// developer has running — which is how this file's own tests first "failed".
+export async function resolvePorts({
+  projectDir,
+  requested = null,
+  blocks = 24,
+  base = STATIC_PORT_BASE,
+} = {}) {
+  if (requested != null) {
+    return { ports: portsFor(requested), tookOver: true, steppedAside: [] };
+  }
+  const steppedAside = [];
+  for (let i = 0; i < blocks; i++) {
+    const ports = portsFor(base + i * BLOCK_STRIDE);
+    const owner = (await portInUse(ports.static)) ? await whoIsOn(ports.static) : undefined;
+
+    if (owner === undefined) {
+      // The game port is free — but a block only isolates if the WHOLE stack
+      // fits in it. Half a stack here and half somewhere else is worse than
+      // moving on, so a contaminated block is skipped entire.
+      if ((await portInUse(ports.mp)) || (await portInUse(ports.shim))) {
+        steppedAside.push({ port: ports.static, projectDir: null });
+        continue;
+      }
+      return { ports, tookOver: false, steppedAside };
+    }
+    if (owner && owner.projectDir === projectDir) {
+      return { ports, tookOver: true, steppedAside }; // our own stale server
+    }
+    steppedAside.push({ port: ports.static, projectDir: owner?.projectDir ?? null });
+  }
+  throw new Error(
+    `No free port block after trying ${blocks}. Close a dev server, or pass --port explicitly.`,
+  );
+}
+
 export function portInUse(port) {
   return new Promise((resolve) => {
     const sock = net.connect({ port, host: '127.0.0.1' });

package/lib/publish.mjs

@@ -13,6 +13,7 @@ import { createHash } from 'node:crypto';
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { findProject } from './project.mjs';
+import { isLane } from './lane.mjs';
 import { ensureEngine } from './engine.mjs';
 import { getToken, getApiBase } from './config.mjs';
 import { DEFAULT_API_BASE } from './llm-shim.mjs';
@@ -65,6 +66,26 @@ export async function publish({
   log = console.log,
 } = {}) {
   const project = findProject(cwd);
+
+  // A publish is GLOBAL, PERMANENT and IRREVERSIBLE — the first one claims the
+  // name for this account forever. A lane is a throwaway experiment in a folder
+  // named after it, and the slug defaults to the folder name, so a bare publish
+  // from one would claim "riven-judder" for all time (or 403 against whoever
+  // owns it). And when a game overrides `looop.slug`, the lane inherits it and
+  // would silently overwrite the LIVE game with the experiment.
+  //
+  // A name this permanent is never guessed inside a lane. The guard is on
+  // GUESSING, not on publishing: name it with --slug and it goes through.
+  if (!slug && isLane(project.dir)) {
+    throw new Error(
+      `This is a lane, not your game. Publishing from here would claim the name ` +
+        `"${project.slug}" permanently.\n\n` +
+        `  npx looop publish --slug ${project.slug}-test   # publish an A/B copy to compare\n` +
+        `  npx looop publish --slug <your-game>            # ship this lane AS the real game\n\n` +
+        `Or merge the lane into your game and publish from there.`,
+    );
+  }
+
   // The declared engineVersion must be a version the platform can resolve —
   // ensureEngine keeps the local install synced to the game's pin.
   const engine = await ensureEngine(project.dir, { apiBase, log });

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/static-server.mjs

@@ -13,6 +13,7 @@ import { EventEmitter } from 'node:events';
 import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
 import { extname, join, normalize, sep } from 'node:path';
 import { injectHeadTags, rewriteHtmlScripts, rewriteJsImports, PLATFORM_URL } from './inject.mjs';
+import { WHOAMI_PATH } from './ports.mjs';
 
 const RELOAD_CLIENT = `<script>
 (() => {
@@ -96,6 +97,7 @@ function mtimesChanged(a, b) {
 export function createStaticServer({
   slug,
   mounts,
+  projectDir = null,
   watchDirs = [],
   injectReload = true,
   watchIntervalMs = 400,
@@ -214,6 +216,18 @@ export function createStaticServer({
     const reqUrl = new URL(req.url, 'http://x');
     const urlPath = reqUrl.pathname;
     if (urlPath === '/__reload') return handleSse(res);
+    // Ownership probe (ports.mjs): "whose dev server is this?". It is what lets
+    // another `looop dev` — a lane, another game — tell OUR stale server (kill
+    // and reclaim) from a live one that belongs to somebody else (step around,
+    // never touch). Answering honestly here is what keeps lanes from colliding.
+    if (urlPath === WHOAMI_PATH) {
+      return sendBody(
+        res,
+        200,
+        JSON.stringify({ projectDir, slug, pid: process.pid }),
+        'application/json',
+      );
+    }
     if (urlPath === '/' || urlPath === '/index.html') {
       res.writeHead(302, { Location: gameEntry });
       return res.end();

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.15",
+  "version": "0.1.17",
   "description": "Looop game development CLI — dev server, login, and publishing for standalone Looop games.",
   "type": "module",
   "license": "Apache-2.0",