akanjs 3.0.0-beta.8 → 3.0.0

package/vendor/@akanjs/native/packages/cli/src/lib/apilevel.ts

@@ -0,0 +1,245 @@
+
+
+import { existsSync, readFileSync } from "node:fs";
+import { inflateRawSync } from "node:zlib";
+import { readZip } from "./apk.ts";
+
+export interface ApiClass {
+  since: number;
+  supers: string[];
+  members: Map<string, number>;
+}
+export type ApiVersions = Map<string, ApiClass>;
+
+const parsed = new Map<string, ApiVersions>();
+
+/** Reads api-versions.xml (one element per line, as the SDK ships it). */
+export function loadApiVersions(path: string): ApiVersions {
+  const cached = parsed.get(path);
+  if (cached) return cached;
+  const api: ApiVersions = new Map();
+  let current: ApiClass | null = null;
+  
+  const since = (tag: string) => /\ssince="(\d+)"/.exec(tag)?.[1];
+  const name = (tag: string) => /\sname="([^"]+)"/.exec(tag)![1]!.replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    if (line.startsWith("\t<class ")) {
+      current = { since: Number(since(line) ?? 1), supers: [], members: new Map() };
+      api.set(name(line), current);
+      continue;
+    }
+    if (line.startsWith("\t</class>")) {
+      current = null;
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("\t\t<extends ") || line.startsWith("\t\t<implements ")) {
+      if (!/\sremoved="/.test(line)) current.supers.push(name(line));
+    } else if (line.startsWith("\t\t<method ") || line.startsWith("\t\t<field ")) {
+      const added = since(line);
+      current.members.set(name(line), added ? Number(added) : current.since);
+    }
+  }
+  parsed.set(path, api);
+  return api;
+}
+
+export interface ClassInfo {
+  name: string;
+  superName: string | null;
+  interfaces: string[];
+  /** Classes named in the constant pool (array types stripped). */
+  classes: string[];
+  /** Field and method references: owner, name, descriptor. */
+  members: { owner: string; name: string; descriptor: string; field: boolean }[];
+  /** Interfaces an invokedynamic call site produces (lambdas turned into framework interfaces). */
+  lambdaTypes: string[];
+}
+
+/** The parts of a class file this check needs: the constant pool, this class, its supertypes. */
+export function readClass(bytes: Uint8Array): ClassInfo {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint32(0) !== 0xcafebabe) throw new Error("not a class file");
+  const count = view.getUint16(8);
+  const utf8: (string | undefined)[] = [];
+  const refs: { tag: number; a: number; b: number }[] = [];
+  let p = 10;
+  const decoder = new TextDecoder();
+  for (let i = 1; i < count; i++) {
+    const tag = bytes[p]!;
+    switch (tag) {
+      case 1: {
+        const length = view.getUint16(p + 1);
+        utf8[i] = decoder.decode(bytes.subarray(p + 3, p + 3 + length)); 
+        p += 3 + length;
+        break;
+      }
+      case 3:
+      case 4:
+        p += 5;
+        break;
+      case 5:
+      case 6:
+        p += 9;
+        i++;
+        break; 
+      case 7:
+      case 8:
+      case 16:
+      case 19:
+      case 20:
+        refs[i] = { tag, a: view.getUint16(p + 1), b: 0 };
+        p += 3;
+        break;
+      case 9:
+      case 10:
+      case 11:
+      case 12:
+      case 17:
+      case 18:
+        refs[i] = { tag, a: view.getUint16(p + 1), b: view.getUint16(p + 3) };
+        p += 5;
+        break;
+      case 15:
+        refs[i] = { tag, a: bytes[p + 1]!, b: view.getUint16(p + 2) };
+        p += 4;
+        break;
+      default:
+        throw new Error(`constant pool tag ${tag} at ${p}`);
+    }
+  }
+  const className = (index: number) => utf8[refs[index]!.a]!;
+  const stripArray = (name: string) => name.replace(/^\[+L?/, "").replace(/;$/, "");
+  const info: ClassInfo = { name: "", superName: null, interfaces: [], classes: [], members: [], lambdaTypes: [] };
+  refs.forEach((ref, index) => {
+    if (!ref) return;
+    if (ref.tag === 7) {
+      const name = stripArray(className(index));
+      if (name.includes("/")) info.classes.push(name);
+    } else if (ref.tag === 9 || ref.tag === 10 || ref.tag === 11) {
+      const nat = refs[ref.b]!;
+      info.members.push({
+        owner: stripArray(className(ref.a)),
+        name: utf8[nat.a]!,
+        descriptor: utf8[nat.b]!,
+        field: ref.tag === 9,
+      });
+    } else if (ref.tag === 18) {
+      const descriptor = utf8[refs[ref.b]!.b]!;
+      const produced = /\)L([^;]+);$/.exec(descriptor);
+      if (produced) info.lambdaTypes.push(produced[1]!);
+    }
+  });
+  info.name = className(view.getUint16(p + 2));
+  const superIndex = view.getUint16(p + 4);
+  info.superName = superIndex ? className(superIndex) : null;
+  const interfaces = view.getUint16(p + 6);
+  for (let i = 0; i < interfaces; i++) info.interfaces.push(className(view.getUint16(p + 8 + i * 2)));
+  return info;
+}
+
+/** The API level a class may use: minSdk, a plugin package's minSdk, or N for an `ApiN` class. */
+export function allowedLevel(
+  className: string,
+  minSdk: number,
+  packageLevels: [prefix: string, level: number][] = [],
+): number {
+  let level = minSdk;
+  for (const [prefix, packageLevel] of packageLevels)
+    if (className.startsWith(prefix)) level = Math.max(level, packageLevel);
+  const simple = className.slice(className.lastIndexOf("/") + 1);
+  for (const part of simple.split("$")) {
+    const m = /Api(\d+)$/.exec(part);
+    if (m) level = Math.max(level, Number(m[1]));
+  }
+  return level;
+}
+
+export interface ApiProblem {
+  className: string;
+  what: string;
+  since: number;
+  allowed: number;
+}
+
+/** Checks every class of a jar. */
+export function checkApiLevels(
+  jar: Uint8Array,
+  api: ApiVersions,
+  minSdk: number,
+  packageLevels: [string, number][] = [],
+): ApiProblem[] {
+  const classes: ClassInfo[] = [];
+  for (const entry of readZip(jar)) {
+    if (!entry.name.endsWith(".class")) continue;
+    const data = entry.method === 8 ? new Uint8Array(inflateRawSync(entry.data)) : entry.data;
+    classes.push(readClass(data));
+  }
+  const own = new Map(classes.map((c) => [c.name, c]));
+
+  /** When `member` of `owner` exists in the framework: the API that added it. */
+  const memberSince = (owner: string, member: string, seen = new Set<string>()): number | undefined => {
+    if (seen.has(owner)) return undefined;
+    seen.add(owner);
+    const framework = api.get(owner);
+    if (framework) {
+      const since = framework.members.get(member);
+      if (since !== undefined) return since;
+      for (const s of framework.supers) {
+        const found = memberSince(s, member, seen);
+        if (found !== undefined) return found;
+      }
+      return undefined;
+    }
+    const app = own.get(owner);
+    if (!app) return undefined;
+    for (const s of [app.superName, ...app.interfaces]) {
+      if (!s) continue;
+      const found = memberSince(s, member, seen);
+      if (found !== undefined) return found;
+    }
+    return undefined;
+  };
+
+  const problems: ApiProblem[] = [];
+  for (const c of classes) {
+    const allowed = allowedLevel(c.name, minSdk, packageLevels);
+    const seen = new Set<string>();
+    const report = (what: string, since: number | undefined) => {
+      if (since === undefined || since <= allowed || seen.has(what)) return;
+      seen.add(what);
+      problems.push({ className: c.name, what, since, allowed });
+    };
+    const supertypes = new Set([c.superName, ...c.interfaces]);
+    for (const s of supertypes) if (s) report(`supertype ${s}`, api.get(s)?.since);
+    for (const name of c.classes) if (!supertypes.has(name)) report(`class ${name}`, api.get(name)?.since);
+    for (const name of c.lambdaTypes) report(`lambda type ${name}`, api.get(name)?.since);
+    for (const m of c.members) {
+      const key = m.field ? m.name : `${m.name}${m.descriptor}`;
+      report(`${m.field ? "field" : "method"} ${m.owner}.${key}`, memberSince(m.owner, key));
+    }
+  }
+  return problems;
+}
+
+/** One line per problem, grouped by class, for a build error. */
+export function formatApiProblems(problems: ApiProblem[], minSdk: number): string {
+  const lines = problems
+    .slice(0, 30)
+    .map(
+      (p) =>
+        `  ${p.className.replace(/\//g, ".")}: ${p.what} needs API ${p.since} (this class may use up to ${p.allowed})`,
+    );
+  if (problems.length > 30) lines.push(`  … and ${problems.length - 30} more`);
+  return [
+    `framework APIs above the app's minSdk ${minSdk}:`,
+    ...lines,
+    `Move each into a class or nested object named ApiN (N = the API it needs) and call it only when Build.VERSION.SDK_INT >= N.`,
+  ].join("\n");
+}
+
+/** api-versions.xml of the SDK platform that android.jar belongs to, when the SDK has it. */
+export function apiVersionsFor(androidJar: string): string | null {
+  const path = androidJar.replace(/android\.jar$/, "data/api-versions.xml");
+  return existsSync(path) ? path : null;
+}

package/vendor/@akanjs/native/packages/cli/src/lib/apk.ts

@@ -0,0 +1,203 @@
+
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { deflateRawSync } from "node:zlib";
+
+interface Entry {
+  name: string;
+  method: 0 | 8;
+  crc: number;
+  compressedSize: number;
+  size: number;
+  data: Uint8Array;
+}
+
+const STORE_EXT = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "heic",
+  "mp4",
+  "webm",
+  "mov",
+  "mp3",
+  "m4a",
+  "ogg",
+  "woff",
+  "woff2",
+  "zip",
+  "gz",
+  "br",
+]);
+const DOS_DATE = (0 << 9) | (1 << 5) | 1; 
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+export function readZip(buf: Uint8Array): Entry[] {
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let eocd = buf.length - 22;
+  while (eocd >= 0 && view.getUint32(eocd, true) !== 0x06054b50) eocd--;
+  if (eocd < 0) throw new Error("not a zip file (no end of central directory)");
+  const count = view.getUint16(eocd + 10, true);
+  let p = view.getUint32(eocd + 16, true);
+  const entries: Entry[] = [];
+  for (let i = 0; i < count; i++) {
+    if (view.getUint32(p, true) !== 0x02014b50) throw new Error("bad central directory header");
+    const method = view.getUint16(p + 10, true);
+    if (method !== 0 && method !== 8) throw new Error(`unsupported compression method ${method}`);
+    const nameLength = view.getUint16(p + 28, true);
+    const extraLength = view.getUint16(p + 30, true);
+    const commentLength = view.getUint16(p + 32, true);
+    const localOffset = view.getUint32(p + 42, true);
+    const compressedSize = view.getUint32(p + 20, true);
+    const dataStart =
+      localOffset + 30 + view.getUint16(localOffset + 26, true) + view.getUint16(localOffset + 28, true);
+    entries.push({
+      name: decoder.decode(buf.subarray(p + 46, p + 46 + nameLength)),
+      method,
+      crc: view.getUint32(p + 16, true),
+      compressedSize,
+      size: view.getUint32(p + 24, true),
+      data: buf.subarray(dataStart, dataStart + compressedSize),
+    });
+    p += 46 + nameLength + extraLength + commentLength;
+  }
+  return entries;
+}
+
+export function fileEntry(name: string, bytes: Uint8Array, store: boolean): Entry {
+  const crc = Bun.hash.crc32(bytes) >>> 0;
+  if (!store) {
+    const deflated = deflateRawSync(bytes, { level: 9 });
+    if (deflated.length < bytes.length)
+      return { name, method: 8, crc, compressedSize: deflated.length, size: bytes.length, data: deflated };
+  }
+  return { name, method: 0, crc, compressedSize: bytes.length, size: bytes.length, data: bytes };
+}
+
+export function writeZip(entries: Entry[]): Uint8Array {
+  const chunks: Uint8Array[] = [];
+  const central: Uint8Array[] = [];
+  let offset = 0;
+  for (const e of entries) {
+    const name = encoder.encode(e.name);
+    let extra: Uint8Array = new Uint8Array(0);
+    if (e.method === 0) {
+      
+      const base = offset + 30 + name.length;
+      const pad = (4 - ((base + 6) % 4)) % 4;
+      extra = new Uint8Array(6 + pad);
+      const xv = new DataView(extra.buffer);
+      xv.setUint16(0, 0xd935, true);
+      xv.setUint16(2, 2 + pad, true);
+      xv.setUint16(4, 4, true);
+    }
+    const local = new Uint8Array(30);
+    const lv = new DataView(local.buffer);
+    lv.setUint32(0, 0x04034b50, true);
+    lv.setUint16(4, 20, true);
+    lv.setUint16(6, 0x0800, true); 
+    lv.setUint16(8, e.method, true);
+    lv.setUint16(12, DOS_DATE, true);
+    lv.setUint32(14, e.crc, true);
+    lv.setUint32(18, e.compressedSize, true);
+    lv.setUint32(22, e.size, true);
+    lv.setUint16(26, name.length, true);
+    lv.setUint16(28, extra.length, true);
+
+    const header = new Uint8Array(46);
+    const cv = new DataView(header.buffer);
+    cv.setUint32(0, 0x02014b50, true);
+    cv.setUint16(4, 20, true);
+    cv.setUint16(6, 20, true);
+    cv.setUint16(8, 0x0800, true);
+    cv.setUint16(10, e.method, true);
+    cv.setUint16(14, DOS_DATE, true);
+    cv.setUint32(16, e.crc, true);
+    cv.setUint32(20, e.compressedSize, true);
+    cv.setUint32(24, e.size, true);
+    cv.setUint16(28, name.length, true);
+    cv.setUint32(42, offset, true);
+
+    central.push(header, name);
+    chunks.push(local, name, extra, e.data);
+    offset += 30 + name.length + extra.length + e.data.length;
+  }
+  const centralSize = central.reduce((n, c) => n + c.length, 0);
+  const end = new Uint8Array(22);
+  const ev = new DataView(end.buffer);
+  ev.setUint32(0, 0x06054b50, true);
+  ev.setUint16(8, entries.length, true);
+  ev.setUint16(10, entries.length, true);
+  ev.setUint32(12, centralSize, true);
+  ev.setUint32(16, offset, true);
+
+  const all = [...chunks, ...central, end];
+  const out = new Uint8Array(all.reduce((n, c) => n + c.length, 0));
+  let p = 0;
+  for (const c of all) {
+    out.set(c, p);
+    p += c.length;
+  }
+  return out;
+}
+
+function walk(dir: string): string[] {
+  return readdirSync(dir).flatMap((name) => {
+    const path = join(dir, name);
+    return statSync(path).isDirectory() ? walk(path) : [path];
+  });
+}
+
+export interface ApkInput {
+  /** aapt2 link output (manifest + resources, no assets). */
+  base: Uint8Array;
+  /** classes.dex, classes2.dex, ... in order. */
+  dex: Uint8Array[];
+  /** Folder whose content goes under assets/. */
+  assetsDir: string;
+  /**
+   * More files by their path in the APK (O8): lib/<abi>/*.so of pinned libraries (compressed: the
+   * installer extracts them, extractNativeLibs is not set) and META-INF/services/* for ServiceLoader.
+   */
+  extra?: { name: string; bytes: Uint8Array }[];
+}
+
+export function assembleApk({ base, dex, assetsDir, extra = [] }: ApkInput): Uint8Array {
+  const entries = readZip(base);
+  for (const [i, bytes] of dex.entries())
+    entries.push(fileEntry(i === 0 ? "classes.dex" : `classes${i + 1}.dex`, bytes, true));
+  for (const e of extra) entries.push(fileEntry(e.name, e.bytes, false));
+  for (const file of walk(assetsDir).sort()) {
+    const rel = relative(assetsDir, file).split("\\").join("/");
+    const ext = rel.split(".").pop()!.toLowerCase();
+    entries.push(fileEntry(`assets/${rel}`, new Uint8Array(readFileSync(file)), STORE_EXT.has(ext)));
+  }
+  return writeZip(entries);
+}
+
+/**
+ * The base module of an Android App Bundle (akanjs readiness O1-5), for `bundletool build-bundle
+ * --modules`: aapt2's --proto-format output with its manifest under manifest/ (resources.pb and res/
+ * stay at the root), the dex files under dex/ and the assets under assets/. bundletool decides the
+ * APKs' compression and alignment itself.
+ */
+export function assembleBundleModule({ base, dex, assetsDir, extra = [] }: ApkInput): Uint8Array {
+  const entries = readZip(base).map((e) =>
+    e.name === "AndroidManifest.xml" ? { ...e, name: "manifest/AndroidManifest.xml" } : e,
+  );
+  for (const [i, bytes] of dex.entries())
+    entries.push(fileEntry(`dex/${i === 0 ? "classes.dex" : `classes${i + 1}.dex`}`, bytes, false));
+  
+  for (const e of extra) entries.push(fileEntry(e.name.startsWith("lib/") ? e.name : `root/${e.name}`, e.bytes, false));
+  for (const file of walk(assetsDir).sort()) {
+    const rel = relative(assetsDir, file).split("\\").join("/");
+    const ext = rel.split(".").pop()!.toLowerCase();
+    entries.push(fileEntry(`assets/${rel}`, new Uint8Array(readFileSync(file)), STORE_EXT.has(ext)));
+  }
+  return writeZip(entries);
+}

package/vendor/@akanjs/native/packages/cli/src/lib/args.ts

@@ -0,0 +1,44 @@
+import { CliError } from "./log.ts";
+
+export interface ParsedArgs {
+  positional: string[];
+  flags: Record<string, string | true>;
+}
+
+/** Parses `a b --flag value --bool --key=value`. A flag followed by another flag or nothing is boolean. */
+export function parseArgs(argv: string[], booleanFlags: readonly string[] = []): ParsedArgs {
+  const positional: string[] = [];
+  const flags: Record<string, string | true> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const body = arg.slice(2);
+    const eq = body.indexOf("=");
+    if (eq >= 0) {
+      flags[body.slice(0, eq)] = body.slice(eq + 1);
+    } else if (booleanFlags.includes(body) || i + 1 >= argv.length || argv[i + 1]!.startsWith("--")) {
+      flags[body] = true;
+    } else {
+      flags[body] = argv[++i]!;
+    }
+  }
+  return { positional, flags };
+}
+
+/** Rejects flags a command does not know (a typo would otherwise be ignored, e.g. --relase). */
+export function checkFlags(args: ParsedArgs, known: readonly string[], usage: string): void {
+  const unknown = Object.keys(args.flags).filter((f) => !known.includes(f));
+  if (unknown.length)
+    throw new CliError(
+      `unknown flag${unknown.length > 1 ? "s" : ""} ${unknown.map((f) => `--${f}`).join(", ")}\nusage: ${usage}`,
+      2,
+    );
+}
+
+export function stringFlag(args: ParsedArgs, name: string): string | undefined {
+  const value = args.flags[name];
+  return typeof value === "string" ? value : undefined;
+}

package/vendor/@akanjs/native/packages/cli/src/lib/boot.ts

@@ -0,0 +1,73 @@
+
+
+import type { Platform, PluginDecl, ResolvedAcl } from "../../../core/src/index.ts";
+import { BRIDGE_FEATURES } from "../../../core/src/protocol.ts";
+import { VERSION } from "../../../core/src/version.ts";
+import { resolveAcl } from "./acl.ts";
+import { nativeApi, nativeApiHash, writeBundleInfo } from "./compat.ts";
+import { type NativePlatform, pluginDecls } from "./native-plugins.ts";
+import type { BuildContext } from "./prepare.ts";
+import type { Project, ResolvedConfig } from "./project.ts";
+
+export { INIT_PREFIX, INIT_SUFFIX, renderInitScript } from "../../../core/src/protocol.ts";
+
+export interface BootData {
+  v: 1;
+  platform: Platform;
+  runtimeVersion: string;
+  dev: boolean;
+  app: { id: string; name: string; version: string; build: number };
+  plugins: Record<string, PluginDecl>;
+  /** Resolved capabilities (PL-11): the host enforces them before dispatching a call. */
+  acl?: ResolvedAcl;
+  /** Native builds: what web bundles this binary can run (UP-3, lib/compat.ts). */
+  nativeApi?: string;
+  /** Native builds: what the hosts speak beyond bridge protocol v1 (architecture.md §4). */
+  bridge?: { features: string[] };
+}
+
+/** Without `project` there is no ACL (everything allowed), as in unit tests of other parts. */
+export function makeBoot(
+  config: ResolvedConfig,
+  platform: Platform,
+  plugins: Record<string, PluginDecl>,
+  dev: boolean,
+  project?: Project,
+): BootData {
+  const acl = project ? resolveAcl(config.capabilities, project.plugins, platform) : undefined;
+  return {
+    v: 1,
+    platform,
+    runtimeVersion: runtimeVersion(),
+    dev,
+    app: { id: config.app.id, name: config.app.name, version: config.app.version, build: config.app.build },
+    plugins,
+    ...(acl ? { acl } : {}),
+    ...(project && platform !== "web"
+      ? { nativeApi: nativeApiHash(nativeApi(project, platform, plugins, acl, runtimeVersion())) }
+      : {}),
+    ...(platform !== "web" ? { bridge: { features: [...BRIDGE_FEATURES] } } : {}),
+  };
+}
+
+/** boot.json of a native build, with <outDir>/bundle.json written next to the build (UP-3). */
+export function makeNativeBoot(ctx: BuildContext, platform: NativePlatform): BootData {
+  const { project } = ctx;
+  const decls = pluginDecls(project.plugins, platform);
+  const boot = makeBoot(project.config, platform, decls, ctx.dev, project);
+  writeBundleInfo(
+    ctx.outDir,
+    project,
+    platform,
+    boot.runtimeVersion,
+    nativeApi(project, platform, decls, boot.acl, boot.runtimeVersion),
+    ctx.webDir,
+    ctx.html,
+  );
+  return boot;
+}
+
+/** The runtime version (UP-3, packages/core/src/version.ts). */
+export function runtimeVersion(): string {
+  return VERSION;
+}

package/vendor/@akanjs/native/packages/cli/src/lib/chrome.ts

@@ -0,0 +1,89 @@
+
+
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CliError } from "./log.ts";
+
+const CANDIDATES = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+];
+
+export function findChrome(): string {
+  const found =
+    [process.env.AKAN_NATIVE_CHROME, ...CANDIDATES].find((p): p is string => !!p && existsSync(p)) ??
+    Bun.which("google-chrome") ??
+    Bun.which("chromium");
+  if (!found) throw new CliError("no Chrome/Chromium found for `akan-native test web` (set AKAN_NATIVE_CHROME)");
+  return found;
+}
+
+function formatArg(arg: { type: string; value?: unknown; description?: string }): string {
+  if (arg.value !== undefined) return typeof arg.value === "string" ? arg.value : JSON.stringify(arg.value);
+  return arg.description ?? arg.type;
+}
+
+/** Opens `url` in a fresh headless profile and forwards console lines and exceptions. */
+export async function openHeadless(
+  url: string,
+  onLine: (line: string) => void,
+): Promise<{ stop(): void; exited: Promise<number> }> {
+  const profile = mkdtempSync(join(tmpdir(), "akan-native-chrome-"));
+  const port = 9300 + Math.floor(Math.random() * 500);
+  const chrome = Bun.spawn(
+    [
+      findChrome(),
+      "--headless=new",
+      "--disable-gpu",
+      "--no-first-run",
+      "--no-default-browser-check",
+      `--user-data-dir=${profile}`,
+      `--remote-debugging-port=${port}`,
+      "about:blank",
+    ],
+    { stdin: "ignore", stdout: "ignore", stderr: "ignore" },
+  );
+  let target: { webSocketDebuggerUrl: string } | undefined;
+  for (let i = 0; i < 100 && !target; i++) {
+    await Bun.sleep(100);
+    const list = (await fetch(`http://127.0.0.1:${port}/json`)
+      .then((r) => r.json())
+      .catch(() => [])) as { type: string; webSocketDebuggerUrl: string }[];
+    target = list.find((t) => t.type === "page");
+  }
+  if (!target) {
+    chrome.kill();
+    throw new CliError("headless Chrome did not start");
+  }
+  const ws = new WebSocket(target.webSocketDebuggerUrl);
+  await new Promise((resolve, reject) => {
+    ws.onopen = resolve;
+    ws.onerror = reject;
+  });
+  let id = 0;
+  const send = (method: string, params: object = {}) => ws.send(JSON.stringify({ id: ++id, method, params }));
+  ws.onmessage = (event) => {
+    const message = JSON.parse(String(event.data));
+    if (message.method === "Runtime.consoleAPICalled") {
+      onLine(`[page ${message.params.type}] ${message.params.args.map(formatArg).join(" ")}`);
+    } else if (message.method === "Runtime.exceptionThrown") {
+      const details = message.params.exceptionDetails;
+      onLine(`[page error] ${details.exception?.description ?? details.text}`);
+    }
+  };
+  send("Runtime.enable");
+  send("Page.enable");
+  send("Page.navigate", { url });
+  return {
+    exited: chrome.exited,
+    stop() {
+      try {
+        ws.close();
+      } catch {}
+      chrome.kill();
+      rmSync(profile, { recursive: true, force: true });
+    },
+  };
+}