@joystack/cli 0.0.0-stage → 0.1.43

package/lib/agent-surface.mjs

@@ -0,0 +1,333 @@
+// The agent surface — skills + the Layer-0 managed block — and how an update
+// reaches a repo that already exists (creator-harness Slice 2, decision Q2).
+//
+// The surface ships INSIDE the versioned engine artifact, and ONLY there — the
+// npm CLI carries no copy of it. That is what makes the ownership record below
+// trustworthy: `create` places the surface by calling straight into this module
+// (against the artifact it just installed), so the bytes on disk and the hashes
+// we record come from the same place, and a fresh repo's first `update` is a
+// genuine no-op. The CLI used to seed the surface from its own bundled
+// `template/`, stamped with the ENGINE's version — a record that was false the
+// moment npm and the engine registry shipped out of step, and that made the
+// first `update` overwrite (or DELETE, via the orphan prune below) skills on a
+// repo minutes old.
+//
+// **This runs under `joystack update` — and under `joystack create`** — never on
+// `dev` or `publish`. It COULD run there safely (it can only ever converge a
+// repo to the engine version already pinned in its package.json, never a newer one),
+// but a creator who ran `dev` and then found files they never wrote sitting in
+// `git status` would be right to feel we'd gone through their pockets. Updates
+// are something you ASK for. So this module writes nothing on its own schedule,
+// and it narrates nothing either: it returns what it did, and `joystack update`
+// tells the creator, who decides whether to commit it.
+//
+// The one contract everything here serves:
+//
+//     an update always lands Joystack's surface, and never loses the
+//     creator's content — anything it replaces or removes is backed up
+//     and reported.
+//
+// Ownership is by PATH (note hx3kd9): a path the artifact ships belongs to the
+// platform and always converges to the artifact's version. On each run a file at
+// a shipped path is one of:
+//
+//   content already equal to the incoming  → heal the record, silently
+//   ours, unmodified (hash == recorded)    → replace with the new
+//   anything else on disk                  → back it up, replace, report lossy
+//   not on disk                            → place ours
+//   retired upstream / orphaned            → remove (backup + lossy when the
+//                                            content didn't match the record)
+//
+// There is deliberately no keep-theirs outcome. The old model kept edited
+// files and "shadowed" the incoming version — which permanently froze a file
+// out of every future update after a single (usually agent-made, usually
+// unnoticed) edit, breaking the harness for that repo silently (fb_3a0bea).
+// The hash record in `.joystack/agent-surface.json` is therefore not an ownership
+// gate anymore: it is a change DETECTOR, kept so the report can say "this had
+// local content" honestly instead of warning on every write. `lossy` is that
+// report; `joystack update` narrates it and the /update-joystack skill asks the
+// creator what to do with each lost edit.
+//
+// A skill we never ship is never even enumerated, so a creator's own skills
+// are invisible to this code by construction. `AGENTS.md` is the sanctioned
+// home for creator additions: the managed block between the markers is ours to
+// rewrite; everything outside them (their title, their instructions below the
+// end marker) is theirs and is spliced back untouched — and when the markers
+// themselves have been deleted, the block is re-appended below their content
+// rather than contesting any of it.
+import { createHash } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { LEGACY_MANAGED_MARKERS, stateDir } from './legacy-names.mjs';
+
+export const SURFACE_DIR = 'agent-surface';
+export const LOCAL_MANIFEST = '.joystack/agent-surface.json';
+const localManifestPath = (projectDir) => join(stateDir(projectDir), 'agent-surface.json');
+
+const START = '<!-- joystack:managed:start -->';
+const END = '<!-- joystack:managed:end -->';
+
+const sha = (buf) => createHash('sha256').update(buf).digest('hex');
+
+// Where each artifact path lands in the game repo. `skills/**` is the whole
+// surface today; AGENTS.md is spliced rather than written whole.
+// Targets are manifest keys, not host paths: forward slashes on every platform,
+// because they are recorded in .joystack/agent-surface.json, compared with
+// `startsWith(`${dest}/`)`, and reported to the creator. `join(projectDir, dest)`
+// turns one into a host path wherever the filesystem is touched.
+function target(rel) {
+  if (rel === 'AGENTS.md') return 'AGENTS.md';
+  if (rel.startsWith('skills/')) return `.claude/${rel}`;
+  return null; // unknown surface entry from a newer engine — ignore, don't guess
+}
+
+function projectName(projectDir) {
+  try {
+    return JSON.parse(readFileSync(join(projectDir, 'package.json'), 'utf8')).name || '';
+  } catch {
+    return '';
+  }
+}
+
+function readLocal(projectDir) {
+  try {
+    const m = JSON.parse(readFileSync(localManifestPath(projectDir), 'utf8'));
+    return { engineVersion: m.engineVersion ?? null, placed: m.placed ?? {} };
+  } catch {
+    return null; // no manifest = a pre-Slice-2 repo; see `adopt` below
+  }
+}
+
+function writeLocal(projectDir, engineVersion, placed) {
+  const p = localManifestPath(projectDir);
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, JSON.stringify({ engineVersion, placed }, null, 2) + '\n');
+}
+
+// Removing the last SKILL.md from a skill folder must remove the folder too —
+// an empty `.claude/skills/handbook/` still reads to an agent as a skill that
+// exists and is broken. Walks up, stopping at .claude/skills (never the repo).
+function pruneEmptyDirs(projectDir, dest) {
+  let dir = dirname(join(projectDir, dest));
+  const stop = join(projectDir, '.claude', 'skills');
+  while (dir.startsWith(stop) && dir !== stop) {
+    try {
+      if (readdirSync(dir).length) return;
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      return;
+    }
+    dir = dirname(dir);
+  }
+}
+
+// Whether everything on disk at `dest` (a file, or a whole skill folder) still
+// matches the hashes recorded for it. Distinguishes a clean retire/orphan
+// removal from one that destroys real local content — only the latter earns a
+// backup and a `lossy` report. A file with no record at all counts as
+// non-matching: content we can't vouch for is content to preserve.
+function contentMatchesRecord(abs, dest, placed) {
+  if (!statSync(abs).isDirectory()) {
+    return placed[dest] !== undefined && sha(readFileSync(abs)) === placed[dest];
+  }
+  const entries = readdirSync(abs, { recursive: true, withFileTypes: true }).filter((e) => e.isFile());
+  if (!entries.length) return true; // an empty folder holds nothing to lose
+  return entries.every((e) => {
+    const file = join(e.parentPath, e.name);
+    const rel = `${dest}/${relative(abs, file).split('\\').join('/')}`;
+    return placed[rel] !== undefined && sha(readFileSync(file)) === placed[rel];
+  });
+}
+
+// Splice the artifact's managed block into the repo's AGENTS.md, preserving
+// everything outside the markers. Returns null when the creator's file has no
+// markers; the caller then re-appends the block below their content.
+// A file written by the old engine carries the block between its old marker
+// names; the splice replaces it with the block under the current ones.
+function spliceManaged(current, incoming) {
+  const span = [{ start: START, end: END }, LEGACY_MANAGED_MARKERS]
+    .map(({ start, end }) => [current.indexOf(start), current.indexOf(end), end.length])
+    .find(([cs, ce]) => cs !== -1 && ce !== -1 && ce >= cs);
+  if (!span) return null;
+  const [cs, ce, endLength] = span;
+
+  const is = incoming.indexOf(START);
+  const ie = incoming.indexOf(END);
+  if (is === -1 || ie === -1) return null;
+
+  const block = incoming.slice(is, ie + END.length);
+  return current.slice(0, cs) + block + current.slice(ce + endLength);
+}
+
+/**
+ * Reconcile the game repo's agent surface against the installed engine artifact.
+ * Never throws: a malformed or absent surface must not block `joystack dev`.
+ */
+export function reconcileAgentSurface(projectDir, engineDir, { log = console.log } = {}) {
+  const result = {
+    placed: [], removed: [], lossy: [], backups: [],
+    adopted: false, skipped: false, engineVersion: null, backupDir: null,
+  };
+  const surface = join(engineDir, SURFACE_DIR);
+
+  let manifest;
+  try {
+    if (!existsSync(join(surface, 'manifest.json'))) {
+      result.skipped = true; // engine older than Slice 2 — it carries no surface
+      return result;
+    }
+    manifest = JSON.parse(readFileSync(join(surface, 'manifest.json'), 'utf8'));
+  } catch (err) {
+    log(`⚠️  Could not read the engine's agent surface (${err.message}) — skills left as they are.`);
+    result.skipped = true;
+    return result;
+  }
+
+  try {
+    const name = projectName(projectDir);
+    const render = (buf) => Buffer.from(buf.toString('utf8').replaceAll('{{name}}', name), 'utf8');
+
+    const prior = readLocal(projectDir);
+    // Adoption: a repo scaffolded before this mechanism existed has our files on
+    // disk but no record of them. We take ownership so it can ever be updated —
+    // and back up anything whose bytes diverge, so an edit we can't distinguish
+    // from ours is preserved rather than destroyed.
+    const adopt = prior === null;
+    result.adopted = adopt;
+    const placed = adopt ? {} : { ...prior.placed };
+
+    const backupRoot = join(stateDir(projectDir), `backup-${manifest.engineVersion}`);
+    const backups = [];
+    const backup = (rel) => {
+      const from = join(projectDir, rel);
+      if (!existsSync(from)) return;
+      const to = join(backupRoot, rel);
+      mkdirSync(dirname(to), { recursive: true });
+      cpSync(from, to, { recursive: true });
+      backups.push(rel);
+    };
+
+    // ── retired entries: remove what upstream dropped. This is the half that
+    //    makes a RENAME possible on a repo that already exists — without it a
+    //    replaced skill would linger next to its replacement forever, still
+    //    loaded by the creator's agent as live guidance. Removal is
+    //    unconditional (the path is Joystack's); content that doesn't match
+    //    the record is preserved in the backup and reported lossy. ───────────
+    for (const rel of manifest.retired ?? []) {
+      const dest = target(rel);
+      if (!dest) continue;
+      const abs = join(projectDir, dest);
+      if (!existsSync(abs)) continue;
+
+      if (adopt) {
+        backup(dest); // no record to compare — preserve, but don't accuse
+      } else if (!contentMatchesRecord(abs, dest, placed)) {
+        backup(dest);
+        result.lossy.push(dest);
+      }
+      rmSync(abs, { recursive: true, force: true });
+      for (const p of Object.keys(placed)) {
+        if (p === dest || p.startsWith(`${dest}/`)) delete placed[p];
+      }
+      result.removed.push(dest);
+    }
+
+    // ── the live surface ────────────────────────────────────────────────────
+    for (const rel of Object.keys(manifest.files ?? {})) {
+      const dest = target(rel);
+      if (!dest) continue;
+      const src = join(surface, rel);
+      if (!existsSync(src)) continue;
+
+      const abs = join(projectDir, dest);
+      const desired = render(readFileSync(src));
+      const exists = existsSync(abs);
+      const current = exists ? readFileSync(abs) : null;
+      const recorded = placed[dest];
+
+      if (dest === 'AGENTS.md') {
+        // The markers ARE the contract: inside is ours, outside is theirs.
+        const desiredStr = desired.toString('utf8');
+        let next = exists ? spliceManaged(current.toString('utf8'), desiredStr) : desiredStr;
+        if (next === null) {
+          // Their file has no markers — they (or their agent) rewrote Layer 0.
+          // The block must still land, but everything they wrote is theirs, so
+          // it is re-appended below their content, touching none of it.
+          const is = desiredStr.indexOf(START);
+          const ie = desiredStr.indexOf(END);
+          if (is === -1 || ie === -1) continue; // artifact itself has no block — nothing to land
+          next = current.toString('utf8').replace(/\s*$/, '\n\n') + desiredStr.slice(is, ie + END.length) + '\n';
+        }
+        if (exists && current.toString('utf8') === next) continue;
+        writeFileSync(abs, next);
+        placed[dest] = sha(Buffer.from(next, 'utf8'));
+        result.placed.push(dest);
+        continue;
+      }
+
+      if (exists) {
+        const now = sha(current);
+        if (now === sha(desired)) {
+          // Content already equal — including the frozen-record case where a
+          // local edit was independently upstreamed (fb_3a0bea). Nothing to
+          // write, nothing lost; heal the record so future updates apply.
+          placed[dest] = now;
+          continue;
+        }
+        if (adopt) {
+          backup(dest); // no record to compare — preserve, but don't accuse
+        } else if (now !== recorded) {
+          // Edited ours, or never ours — either way real local content is
+          // about to be replaced: preserve it and report it for the ask flow.
+          backup(dest);
+          result.lossy.push(dest);
+        }
+      }
+
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, desired);
+      placed[dest] = sha(desired);
+      result.placed.push(dest);
+    }
+
+    // ── orphans: anything WE placed that the artifact no longer ships ────────
+    // Deleting a skill upstream is enough to delete it here — no declaration,
+    // nothing to remember. The manifest already knows what we put on disk, so a
+    // file of ours that vanished from the artifact has been retired, full stop.
+    // (`retired` above still earns its keep: on ADOPTION there is no manifest,
+    // so an orphan is indistinguishable from a skill the creator wrote.)
+    const shipped = new Set(
+      Object.keys(manifest.files ?? {})
+        .map(target)
+        .filter(Boolean),
+    );
+    for (const dest of Object.keys(placed)) {
+      if (shipped.has(dest)) continue;
+      const abs = join(projectDir, dest);
+      if (existsSync(abs)) {
+        if (sha(readFileSync(abs)) !== placed[dest]) {
+          // They changed it — the retirement still lands, the content survives
+          // in the backup and the caller asks the creator about it.
+          backup(dest);
+          result.lossy.push(dest);
+        }
+        rmSync(abs, { force: true });
+        pruneEmptyDirs(projectDir, dest);
+        result.removed.push(dest);
+      }
+      delete placed[dest];
+    }
+
+    writeLocal(projectDir, manifest.engineVersion, placed);
+    result.engineVersion = manifest.engineVersion;
+    result.backups = backups;
+    result.backupDir = backups.length
+      ? `${LOCAL_MANIFEST.replace('agent-surface.json', '')}backup-${manifest.engineVersion}/`
+      : null;
+  } catch (err) {
+    // A surface bug must never be the reason a creator can't run their game.
+    log(`⚠️  Could not sync the agent skills (${err.message}) — continuing; your game is unaffected.`);
+  }
+
+  return result;
+}

package/lib/assets-json.mjs

@@ -0,0 +1,205 @@
+// `joystack assets --json [<id>…]` — what each asset IS, as JSON, for an agent
+// to read without a screenshot: its id, label, stage and type, its parameters
+// with their `describe`, the stats measured from what it built, its capability
+// flags (rigged, clips, emissive, a sound's length) and its reference images.
+//
+// The numbers are the Assets page's own. The command opens the page headless
+// (shared/ui/assets/headless.mjs), and for each asset calls
+// `window.joystackAssets.asset(id)`, which selects it, waits for it to finish
+// building and measures it on the stage — the same measurement the page's
+// stats line shows. Nothing here counts anything.
+//
+//   joystack assets --json                  every declared asset (≈20–40 s for 70)
+//   joystack assets --json saucer medusa    just these
+//
+// ── WHAT IS TRUSTED ─────────────────────────────────────────────────────────
+//
+// The ids on the command line are the creator's own; they are only compared
+// against the declared ids and passed to the page as data. Everything that
+// comes back is text the game's code produced (labels, notes, readouts), so
+// the JSON is printed with every control and text-direction character
+// escaped (safeJson): it parses to exactly the same data, and a terminal
+// showing it acts on none of it. Errors that quote the page are stripped the
+// way `--sheet` strips them (printable), and every answer from the page is
+// timed here, since the page's own timers belong to the game's code.
+//
+// This guards against the game's code in the PAGE. The page driver and
+// playwright are loaded from the game's own node_modules, so a game folder
+// that arrives with its node_modules already in it can run anything as the
+// person running the command; install dependencies yourself before running
+// a command on a folder from someone else.
+
+import { findProject } from './project.mjs';
+import { findRunningStack, ASSETS_PAGE_PATH } from './assets-page.mjs';
+import { engineTooOld, loadDriver, loadPlaywright, printable } from './assets-sheet.mjs';
+import { gpuArgs } from './smoke-gpu-preload.mjs';
+import { readEnv } from './legacy-names.mjs';
+
+export const JSON_HELP = `joystack assets --json [<id>…] [--port <n>]
+
+  Prints what each asset is, as JSON: id, label, note, stage, type, the file
+  it was declared from, its parameters (with each one's describe), the stats
+  measured from what it built (triangles, meshes, materials, draw calls,
+  bones, size in game units, palette), a sound's length, its flags (rigged,
+  clips, emissive, seconds), its readout and its reference image paths.
+
+  With no ids, every declared asset, one after another (about half a second
+  each). An id that is not declared is an error that lists the ones that are.
+  An asset that will not build is listed with "error" set, and the command
+  then exits 1.
+
+  Uses the dev stack already running for this game, or starts one for the
+  length of the command. Needs playwright in the game (npm i -D playwright).`;
+
+// Flags of this mode that take no value. Any other flag is a typo and is
+// refused, as `--sheet` refuses one, rather than read as an asset id.
+const JSON_SWITCHES = new Set(['--json', '--no-open', '--help']);
+
+// The arguments after `joystack assets`, read for the JSON mode: { ids, port }.
+// Ids keep their order; one asked for twice is listed once.
+export function parseJsonArgs(rest = []) {
+  const ids = [];
+  let port = null;
+  for (let i = 0; i < rest.length; i += 1) {
+    const a = rest[i];
+    if (a === '--sheet') throw new Error(`--json and --sheet are two different outputs; ask for one.\n\n${JSON_HELP}`);
+    if (a === '--port') {
+      const v = rest[i + 1];
+      if (v == null || v.startsWith('--')) throw new Error(`--port needs a value.\n\n${JSON_HELP}`);
+      i += 1;
+      const p = Number(v);
+      if (!Number.isInteger(p) || p <= 0 || p > 65535) throw new Error('--port needs a port number');
+      port = p;
+    } else if (a.startsWith('--')) {
+      if (!JSON_SWITCHES.has(a)) throw new Error(`joystack assets --json has no option ${a}.\n\n${JSON_HELP}`);
+    } else if (!ids.includes(a)) ids.push(a);
+  }
+  return { ids, port };
+}
+
+// JSON with every character a terminal could act on written as an escape.
+// JSON.stringify already escapes U+0000–U+001F; this adds DEL and the C1
+// controls (U+007F–U+009F, which include a one-byte CSI), the line and
+// paragraph separators, and the bidirectional overrides and isolates that
+// can make text display in an order other than the one it is in. Escaped,
+// not removed, so the data parses back unchanged.
+const UNSAFE = /[\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g;
+//
+// Never throws. The data came from a page the game's code runs in, and that
+// code can hand back a structure JSON cannot hold (a cycle, a BigInt), whose
+// error message would quote the game's own key names. A cycle is written as
+// "[circular]" and a BigInt as its digits.
+function plain(v, ancestors = []) {
+  if (typeof v === 'bigint') return String(v);
+  if (v === null || typeof v !== 'object') return v;
+  if (ancestors.includes(v)) return '[circular]';
+  const inner = [...ancestors, v];
+  if (Array.isArray(v)) return v.map((x) => plain(x, inner));
+  const out = {};
+  for (const [k, x] of Object.entries(v)) out[k] = plain(x, inner);
+  return out;
+}
+
+export function safeJson(value) {
+  return JSON.stringify(plain(value), null, 2).replace(UNSAFE, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
+
+// How long one answer from the page may take, measured here rather than in
+// the page: the page's own timers belong to the game's code, which can stop
+// them. The page gives a mount 20 s and a late model 3 s more, so this only
+// fires when the page itself has stopped answering.
+const ASSET_TIMEOUT_MS = 45_000;
+// Errors the page reported are kept for the output, up to this many, each cut
+// to this length: a game that throws on every frame would otherwise fill it.
+const PAGE_ERRORS_MAX = 50;
+const PAGE_ERROR_CHARS = 1000;
+
+function answer(promise, ms) {
+  let timer;
+  const late = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`the Assets page did not answer within ${ms / 1000} s`)), ms);
+  });
+  return Promise.race([promise, late]).finally(() => clearTimeout(timer));
+}
+
+// Measure the assets. `startDev` starts a dev stack (dev() in the CLI) when
+// none is running for the game. `origin`, `browser` and `headless` are for a
+// caller that already has them (a test): an origin skips looking for a stack,
+// a browser is used and left open, `headless` is the page driver's module.
+// `progress(i, n, id)` is told before each asset is measured; `onStarted`
+// is handed a dev stack this call started, so a caller interrupted (Ctrl-C)
+// can stop it.
+//
+// Resolves { kind, version, assets: [record…], pageErrors }; the record shape
+// is shared/ui/assets/facts.js `assetRecord`.
+export async function assetsJson({
+  cwd = process.cwd(), ids = [], port = null, startDev = null,
+  origin = null, browser = null, headless = null, progress = () => {}, timeoutMs = ASSET_TIMEOUT_MS,
+  onStarted = () => {}, env = process.env,
+} = {}) {
+  // An explicit --port wins; otherwise JOYSTACK_DEV_PORT, as plain `joystack assets`
+  // reads it (assets-page.mjs, openAssets).
+  const fromEnv = Number(readEnv('JOYSTACK_DEV_PORT', env));
+  if (port == null && Number.isInteger(fromEnv) && fromEnv > 0) port = fromEnv;
+  let project = null;
+  let started = null;
+  if (!origin) {
+    project = findProject(cwd);
+    const stack = await findRunningStack({ projectDir: project.dir, port });
+    if (stack) origin = stack.origin;
+    else {
+      if (!startDev) throw new Error('no dev stack is running for this game');
+      started = await startDev({ cwd, port: port ?? undefined, watch: false, reload: false, noMp: true, log: () => {} });
+      onStarted(started);
+      origin = new URL(started.url).origin;
+    }
+  }
+  if (!project && !(headless && browser)) project = findProject(cwd);
+
+  let ownBrowser = null;
+  try {
+    const driver = headless ?? await loadDriver(project.dir, 'joystack assets --json');
+    if (!browser) {
+      const { chromium } = await loadPlaywright(project.dir, 'an asset is measured');
+      ownBrowser = await chromium.launch({ args: gpuArgs() });
+      browser = ownBrowser;
+    }
+    // No list pictures: each asset is mounted once, on the stage, by asset().
+    const first = ids[0] ? `&_item=${encodeURIComponent(ids[0])}` : '';
+    const insp = await driver.openAssetsPage({ browser, url: `${origin}${ASSETS_PAGE_PATH}?_thumbs=0${first}`, viewport: { width: 1280, height: 800 } });
+    try {
+      if (typeof insp.ids !== 'function' || typeof insp.asset !== 'function') {
+        throw engineTooOld('joystack assets --json', project?.dir ?? cwd);
+      }
+      let declared;
+      try {
+        declared = await answer(insp.ids(), timeoutMs);
+      } catch (err) {
+        throw new Error(printable(`the Assets page could not list this game's assets: ${err?.message ?? err}`));
+      }
+      const unknown = ids.filter((id) => !declared.includes(id));
+      if (unknown.length) {
+        throw new Error(printable(`there is no asset ${unknown.map((id) => `"${id}"`).join(', ')} in this game's assets.js. Declared: ${declared.join(', ') || '(none)'}`));
+      }
+      const wanted = ids.length ? ids : declared;
+      const assets = [];
+      for (let i = 0; i < wanted.length; i += 1) {
+        const id = wanted[i];
+        progress(i, wanted.length, id);
+        try {
+          assets.push(await answer(insp.asset(id), timeoutMs));
+        } catch (err) {
+          assets.push({ id, measured: false, error: String(err?.message ?? err) });
+        }
+      }
+      const pageErrors = insp.errors.slice(0, PAGE_ERRORS_MAX).map((e) => printable(e).slice(0, PAGE_ERROR_CHARS));
+      if (insp.errors.length > PAGE_ERRORS_MAX) pageErrors.push(`… and ${insp.errors.length - PAGE_ERRORS_MAX} more`);
+      return { kind: 'joystack-assets', version: 1, assets, pageErrors };
+    } finally {
+      await insp.close();
+    }
+  } finally {
+    if (ownBrowser) await ownBrowser.close();
+    await started?.stop();
+  }
+}