@origingame/engine 0.0.0-stage → 0.1.0

package/src/node/doctor.ts

@@ -0,0 +1,60 @@
+// `og doctor`'s engine checks, as one JSON line: does this package's native
+// addon load, is the web host's wasm built, and can this machine render a
+// frame headless (Metal on a Mac, Vulkan on a GPU). No renderer is a
+// supported configuration, not a problem: the playtests' frames are then
+// unchecked (OG_RENDERER=none makes any machine so).
+//
+//   bun src/node/doctor.ts
+
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { addonPath, loadNativeHost, native } from "./index.ts";
+import { createEngine, type GameToken } from "../runtime.ts";
+import { og } from "../index.ts";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const pkg = join(here, "..", "..");
+const version = (JSON.parse(readFileSync(join(pkg, "package.json"), "utf8")) as { version: string }).version;
+
+const report: Record<string, unknown> = { package: pkg, version };
+const addon = addonPath();
+try {
+  if (!existsSync(addon)) throw new Error(`no addon at ${addon}`);
+  loadNativeHost(addon);
+  report.addon = { ok: true, path: addon, views: native().og_node_views_mode() };
+} catch (e) {
+  report.addon = { ok: false, path: addon, reason: e instanceof Error ? e.message : String(e) };
+}
+const wasm = join(pkg, "dist", "web", "origin-engine_bg.wasm");
+report.wasm = existsSync(wasm) ? { ok: true, path: wasm, bytes: statSync(wasm).size } : { ok: false, path: wasm };
+const publishWasm = join(pkg, "dist", "web-publish", "origin-engine_bg.wasm");
+report.publishWasm = existsSync(publishWasm) ? { ok: true, path: publishWasm, bytes: statSync(publishWasm).size } : { ok: false, path: publishWasm };
+// The 2D publish variant: what `og build --publish` ships for a 2d game (docs/web-export.md §Variants).
+const publishWasm2d = join(pkg, "dist", "web-publish-2d", "origin-engine_bg.wasm");
+report.publishWasm2d = existsSync(publishWasm2d) ? { ok: true, path: publishWasm2d, bytes: statSync(publishWasm2d).size } : { ok: false, path: publishWasm2d };
+// The lanes variants (wasm atomics), one per physics profile beside its
+// publish wasm: `og build` ships the one of the game's profile for cross-origin
+// isolated pages (docs/web-export.md §Lanes, §Variants).
+const lanesWasm = join(pkg, "dist", "web-publish", "origin-engine-lanes_bg.wasm");
+report.lanesWasm = existsSync(lanesWasm) ? { ok: true, path: lanesWasm, bytes: statSync(lanesWasm).size } : { ok: false, path: lanesWasm };
+const lanesWasm2d = join(pkg, "dist", "web-publish-2d", "origin-engine-lanes_bg.wasm");
+report.lanesWasm2d = existsSync(lanesWasm2d) ? { ok: true, path: lanesWasm2d, bytes: statSync(lanesWasm2d).size } : { ok: false, path: lanesWasm2d };
+
+if ((report.addon as { ok: boolean }).ok) {
+  try {
+    const t0 = performance.now();
+    const created = createEngine(og.game({}) as unknown as GameToken);
+    if (!created.ok) throw new Error(created.reason);
+    const attached = JSON.parse(native().og_node_attach_offscreen(created.value.id, 64, 64)) as { ok: boolean; value?: string; reason?: string };
+    if (!attached.ok) throw new Error(attached.reason);
+    const frame = created.value.probe.capture(64, 64) as { width: number } | null;
+    if (!frame) throw new Error("the renderer attached but produced no frame");
+    report.renderer = { ok: true, tier: attached.value, ms: +(performance.now() - t0).toFixed(0) };
+  } catch (e) {
+    report.renderer = { ok: false, reason: e instanceof Error ? e.message : String(e) };
+  }
+} else {
+  report.renderer = { ok: false, reason: "needs the native addon" };
+}
+process.stdout.write(JSON.stringify(report) + "\n");

package/src/node/index.ts

@@ -0,0 +1,102 @@
+// The native host loader: the napi addon (origin-engine.node, built from
+// crates/og-host-node) under bun or node, headless. `loadGame` imports a game
+// bundle and assembles its engine; `og run --headless` drives it (run.ts).
+
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import {
+  ARRAYS,
+  bindHost,
+  boundHost,
+  type ColumnArray,
+  createEngine,
+  type CreateOptions,
+  type Engine,
+  type GameToken,
+  type HostBinding,
+  type Result,
+} from "../runtime.ts";
+import type { HostAbi } from "../generated/abi.ts";
+
+/**
+ * The addon the native loader uses: `OG_NATIVE_ADDON`, else this package's
+ * `native/origin-engine.<platform>-<arch>.node` (a checkout's build), else the
+ * per-platform package npm installed through optionalDependencies
+ * (`@origingame/engine-<platform>-<arch>/origin-engine.node`).
+ */
+export function addonPath(): string {
+  const fromEnv = process.env.OG_NATIVE_ADDON;
+  if (fromEnv) return resolve(fromEnv);
+  const here = dirname(fileURLToPath(import.meta.url));
+  const platform = `${process.platform}-${process.arch}`;
+  const local = join(here, "..", "..", "native", `origin-engine.${platform}.node`);
+  if (existsSync(local)) return local;
+  try {
+    const require = createRequire(import.meta.url) as unknown as { resolve(id: string): string };
+    return require.resolve(`@origingame/engine-${platform}/origin-engine.node`);
+  } catch {
+    return local;
+  }
+}
+
+/** The addon's own symbols beyond the shared ABI. */
+export interface NativeExtras {
+  og_node_views_mode(): string;
+  og_node_attach_offscreen(engine: number, width: number, height: number): string;
+  /** Waits for the offscreen renderer's GPU work (frame-time benches). */
+  og_node_wait_gpu(engine: number): string;
+  og_node_probe_listen(engine: number, port: number): string;
+  og_node_probe_serve(engine: number): number;
+  og_node_probe_close(engine: number): boolean;
+}
+
+let extras: NativeExtras | null = null;
+const arrays = new WeakMap<ArrayBuffer, ColumnArray>();
+
+/** Load the addon and bind the runtime to it (once per process). */
+export function loadNativeHost(path: string = addonPath()): HostBinding {
+  const bound = boundHost();
+  if (bound) return bound;
+  if (!existsSync(path)) {
+    throw new Error(`no native addon at ${path}: build it with \`bun run build\` in packages/engine (scripts/build.sh), or point OG_NATIVE_ADDON at one`);
+  }
+  const addon = createRequire(import.meta.url)(path) as HostAbi<Uint32Array, unknown> & NativeExtras;
+  extras = addon;
+  const binding: HostBinding = {
+    abi: addon,
+    name: "node",
+    columns(raw, kinds, _count) {
+      if (!Array.isArray(raw) || raw.length === 0) return null;
+      // The host hands out the same buffer while a column stays put: so does this.
+      return (raw as ArrayBuffer[]).map((buffer, i) => {
+        const kind = kinds[i]!.array;
+        const known = arrays.get(buffer);
+        if (known && known.constructor.name === kind && known.byteLength === buffer.byteLength) return known;
+        const made = new ARRAYS[kind](buffer);
+        arrays.set(buffer, made);
+        return made;
+      });
+    },
+  };
+  bindHost(binding);
+  return binding;
+}
+
+/** The addon's extras (view mode, offscreen renderer), once loaded. */
+export function native(): NativeExtras {
+  if (!extras) loadNativeHost();
+  return extras!;
+}
+
+/** Import a game bundle (its default export is `og.game(...)`) and assemble its engine (`options.root`: the project whose cooked/ it opens). */
+export async function loadGame(entry: string, options: CreateOptions = {}): Promise<Result<Engine>> {
+  loadNativeHost();
+  const mod = (await import(pathToFileURL(resolve(entry)).href)) as { default?: GameToken };
+  if (!mod.default) return { ok: false, reason: `${entry} has no default export: export default og.game({ ... })` };
+  return createEngine(mod.default, options);
+}
+
+export { createEngine };
+export type { Engine, Result };

package/src/node/platform.ts

@@ -0,0 +1,24 @@
+// The native host's platform: og.platform's calls answered by the local
+// platform (../platform-local.ts) from a JSON file, or from memory. `og run`
+// keeps it in memory unless `--platform-store <file>` names a file, so a
+// scripted run (a playtest) never depends on an earlier one.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { localPlatform, memoryPersistence, type LocalPersistence, type PlatformHost } from "../platform-local.ts";
+
+/** The document in a file, created on the first save. */
+export function filePersistence(path: string): LocalPersistence {
+  return {
+    load: () => (existsSync(path) ? readFileSync(path, "utf8") : null),
+    save: (text) => {
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, text);
+    },
+  };
+}
+
+/** The native platform: a file's store when `path` is given, else memory. */
+export function nativePlatform(path?: string): PlatformHost & { document(): unknown } {
+  return localPlatform(path ? filePersistence(path) : memoryPersistence());
+}

package/src/node/playtest-run.ts

@@ -0,0 +1,249 @@
+// Runs one playtest (`tests/*.og.ts`) for `og test`: the script's commands
+// through `og run --headless --commands` in a fresh process (its `runs` and
+// `then` steps in more), then its checks over the files the runs wrote. A
+// playtest that made no check fails.
+//
+// Without a renderer (tier `none`: the platform's engine and probe
+// sandboxes, OG_RENDERER=none) every check runs as before except those
+// inside `t.frame`, and each screenshot the runs took is reported
+// "no renderer, frame unchecked": one line per frame and a count, never a
+// failure. `--result <file>` also writes the result line there (og test
+// sums the unchecked frames from it).
+//
+//   bun src/node/playtest-run.ts --file <tests/x.og.ts> --entry <game bundle> [--root <project>] [--out <dir>] [--json] [--result <file>]
+
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { bundleGame } from "./build.ts";
+import { FrameUnchecked, PLAYTEST_CLOCK, type PlaytestChecks, type PlaytestDesc, type PlaytestRun } from "../playtest.ts";
+
+declare const Bun: {
+  spawnSync(cmd: string[], o?: { cwd?: string; stdout?: string; stderr?: string }): { exitCode: number; stdout: Uint8Array; stderr: Uint8Array };
+};
+
+const argv = process.argv.slice(2);
+const opt = (name: string) => {
+  const i = argv.indexOf(name);
+  return i >= 0 ? argv[i + 1] : undefined;
+};
+const file = opt("--file");
+const entry = opt("--entry");
+const root = opt("--root");
+const resultFile = opt("--result");
+const asJson = argv.includes("--json");
+if (!file || !entry) {
+  process.stderr.write("usage: bun src/node/playtest-run.ts --file <tests/x.og.ts> --entry <game bundle> [--root <project>] [--out <dir>] [--json]\n");
+  process.exit(2);
+}
+const here = dirname(fileURLToPath(import.meta.url));
+const name = basename(file!).replace(/\.og\.ts$/, "");
+const out = resolve(opt("--out") ?? join(root ?? dirname(file!), "og-out", "test", name));
+rmSync(out, { recursive: true, force: true });
+mkdirSync(out, { recursive: true });
+
+const t0 = performance.now();
+const failures: string[] = [];
+let checks = 0;
+// Checks made inside t.frame (with a renderer): what a run without one leaves out.
+let frameChecks = 0;
+// Every screenshot taken without a renderer, by the file it would have written, in order.
+const unchecked: string[] = [];
+// Notes on unchecked frames beyond the per-file lines (a check stopped by one).
+const notes: string[] = [];
+let result: Record<string, unknown> = {};
+
+function finish(): never {
+  // A playtest whose every check reads a frame has nothing to check without a renderer: it passes, and says so.
+  const ok = failures.length === 0 && (checks > 0 || unchecked.length > 0);
+  if (checks === 0 && failures.length === 0) {
+    if (unchecked.length > 0) notes.push("every check of this playtest reads a frame: nothing was checked without a renderer");
+    else failures.push("the playtest made no check: call t.ok, t.equal or t.near at least once");
+  }
+  const line = { playtest: name, file, ok, checks, frameChecks, unchecked, failures, notes, out, ms: +(performance.now() - t0).toFixed(0), ...result };
+  if (resultFile) {
+    mkdirSync(dirname(resolve(resultFile)), { recursive: true });
+    writeFileSync(resultFile, JSON.stringify(line) + "\n");
+  }
+  if (asJson) process.stdout.write(JSON.stringify(line) + "\n");
+  else {
+    const frames = unchecked.length > 0 ? `, ${unchecked.length} frame${unchecked.length === 1 ? "" : "s"} unchecked` : "";
+    process.stdout.write(`${ok ? "PASS" : "FAIL"} ${name} (${checks} checks${frames}, ${line.ms} ms)${(line as { title?: string }).title ? ": " + (line as { title?: string }).title : ""}\n`);
+    for (const f of failures) process.stdout.write(`  - ${f}\n`);
+    for (const u of unchecked) process.stdout.write(`  ~ ${u}: no renderer, frame unchecked\n`);
+    for (const n of notes) process.stdout.write(`  ~ ${n}\n`);
+  }
+  process.exit(ok ? 0 : 1);
+}
+
+// The playtest module, bundled like the game so `@origingame/engine/playtest` resolves.
+const bundled = join(out, ".playtest.js");
+const b = await bundleGame(file!, bundled, "native");
+if (!b.ok) {
+  failures.push(`the playtest does not bundle: ${b.reason}`);
+  finish();
+}
+const desc = ((await import(pathToFileURL(bundled).href)) as { default?: PlaytestDesc }).default;
+if (!desc || typeof desc.check !== "function") {
+  failures.push(`${file} has no default export: export default playtest({ name, commands, check })`);
+  finish();
+}
+result.title = desc!.name;
+
+// Every process of the playtest: the script, its `runs` and its `then` steps.
+// The host's clock is pinned (PlaytestDesc.clock), so og.platform.now is
+// reproducible; `store: "keep"` shares one local store file between them,
+// kept under a dot name, which no step's output may take (an output named
+// `platform.json` once replaced it: hollowbell FINDINGS #18).
+const store = desc!.store === "keep" ? join(out, ".store", "platform.json") : undefined;
+if (store) mkdirSync(dirname(store), { recursive: true });
+const command = (commands: string, dir: string, clock: number) => {
+  const c = ["bun", join(here, "run.ts"), "--entry", entry!, "--commands", commands, "--out", dir, "--json", "--clock", String(clock)];
+  if (root) c.push("--root", root);
+  if (desc!.seed !== undefined) c.push("--seed", String(desc!.seed));
+  if (desc!.size) c.push("--size", desc!.size);
+  if (store) c.push("--platform-store", store);
+  return c;
+};
+type Summary = { tick: number; hash: string; entities: number; quit: boolean; tier: string; outputs: string[]; warnings: string[]; unchecked?: string[] };
+const spawn = (c: string[], what: string): Summary | null => {
+  const r = Bun.spawnSync(c, { stdout: "pipe", stderr: "pipe" });
+  const stdout = new TextDecoder().decode(r.stdout);
+  const stderr = new TextDecoder().decode(r.stderr);
+  let summary: Summary | null = null;
+  try {
+    summary = JSON.parse(stdout.trim().split("\n").pop() ?? "");
+  } catch {
+    summary = null;
+  }
+  if (r.exitCode !== 0 || !summary) {
+    failures.push(`${what} failed (exit ${r.exitCode}): ${stderr.trim() || stdout.trim()}`);
+    return null;
+  }
+  return summary;
+};
+const clock = desc!.clock ?? PLAYTEST_CLOCK;
+const summary = spawn(command(desc!.commands, out, clock), "og run");
+if (!summary) finish();
+const rendered = summary!.tier !== "none";
+unchecked.push(...(summary!.unchecked ?? []));
+result = { ...result, tick: summary!.tick, hash: summary!.hash, tier: summary!.tier, warnings: summary!.warnings };
+// More runs of the same script (desc.runs), each in a fresh process into its
+// own directory: only their end hashes are kept.
+const hashes = [summary!.hash];
+for (let i = 1; i < Math.max(1, Math.floor(desc!.runs ?? 1)); i++) {
+  const again = spawn(command(desc!.commands, join(out, `.run-${i + 1}`), clock), `run ${i + 1} of ${desc!.runs}`);
+  if (again) hashes.push(again.hash);
+}
+result = { ...result, hashes };
+
+const runOf = (s: Summary, dir: string, later: readonly PlaytestRun[]): PlaytestRun => {
+  const path = (f: string) => {
+    const p = resolve(dir, f);
+    if (!existsSync(p)) throw new Error(`the run wrote no ${f} (it wrote ${s.outputs.map((o) => o.slice(dir.length + 1)).join(", ") || "nothing"})`);
+    return p;
+  };
+  const missed = new Set(s.unchecked ?? []);
+  return {
+    tick: s.tick,
+    hash: s.hash,
+    hashes: dir === out ? hashes : [s.hash],
+    entities: s.entities,
+    quit: s.quit,
+    tier: s.tier,
+    rendered: s.tier !== "none",
+    unchecked: [...missed],
+    files: s.outputs.map((o) => o.slice(dir.length + 1)),
+    warnings: s.warnings,
+    then: later,
+    json: <T>(f: string) => JSON.parse(readFileSync(path(f), "utf8")) as T,
+    text: (f: string) => readFileSync(path(f), "utf8"),
+    png: (f: string) => {
+      if (missed.has(f)) throw new FrameUnchecked(f);
+      const bytes = readFileSync(path(f));
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      if (bytes.length < 24 || view.getUint32(12) !== 0x49484452) throw new Error(`${f} is not a PNG`);
+      return { width: view.getUint32(16), height: view.getUint32(20), bytes: bytes.length };
+    },
+    wav: (f: string) => {
+      const bytes = readFileSync(path(f));
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      if (bytes.length < 44 || view.getUint32(0) !== 0x52494646 || view.getUint32(8) !== 0x57415645) throw new Error(`${f} is not a WAV`);
+      const rate = view.getUint32(24, true);
+      const channels = view.getUint16(22, true);
+      const samples = (bytes.length - 44) >> 1;
+      let peak = 0;
+      let sum = 0;
+      for (let i = 0; i < samples; i++) {
+        const x = view.getInt16(44 + i * 2, true) / 32767;
+        peak = Math.max(peak, Math.abs(x));
+        sum += x * x;
+      }
+      return { rate, frames: samples / Math.max(1, channels), peak, rms: samples > 0 ? Math.sqrt(sum / samples) : 0 };
+    },
+  };
+};
+// The later processes (desc.then), in order, after the script and its runs.
+const later: PlaytestRun[] = [];
+for (const [i, step] of (desc!.then ?? []).entries()) {
+  const dir = join(out, `then-${i + 1}`);
+  mkdirSync(dir, { recursive: true });
+  const s = spawn(command(step.commands, dir, step.clock ?? clock), `then[${i}]`);
+  if (!s) finish();
+  for (const f of s!.unchecked ?? []) unchecked.push(`then[${i}] ${f}`);
+  later.push(runOf(s!, dir, []));
+}
+const run = runOf(summary!, out, later);
+// Every file a run took a screenshot for without a renderer, by name and by path.
+const missedPaths = new Set<string>([...(summary!.unchecked ?? []).map((f) => resolve(out, f)), ...later.flatMap((r, i) => r.unchecked.map((f) => resolve(join(out, `then-${i + 1}`), f)))]);
+const missedNames = new Set<string>([...(summary!.unchecked ?? []), ...later.flatMap((r) => r.unchecked)]);
+let inFrame = false;
+const t: PlaytestChecks = {
+  ok(condition, what) {
+    checks++;
+    if (!condition) failures.push(what);
+  },
+  equal(actual, expected, what) {
+    checks++;
+    if (JSON.stringify(actual) !== JSON.stringify(expected)) failures.push(`${what}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  },
+  near(actual, expected, tolerance, what) {
+    checks++;
+    if (!(Math.abs(actual - expected) <= tolerance)) failures.push(`${what}: expected ${expected} ± ${tolerance}, got ${actual}`);
+  },
+  frame(files, check) {
+    const names = typeof files === "string" ? [files] : [...files];
+    if (!rendered) {
+      // The frames are listed once each, from the runs' own notes; a name no
+      // screenshot took is listed too, so nothing is skipped silently.
+      for (const f of names) if (!missedNames.has(f) && !unchecked.includes(f)) unchecked.push(f);
+      return;
+    }
+    if (inFrame) return check();
+    const before = checks;
+    inFrame = true;
+    try {
+      check();
+    } finally {
+      inFrame = false;
+      frameChecks += checks - before;
+    }
+  },
+};
+/** The file a frame read without a renderer was after, if `e` is one: a FrameUnchecked, or a missing screenshot read from disk. */
+function missedFrame(e: unknown): string | null {
+  if (rendered) return null;
+  // By name too: a playtest's bundle carries its own copy of the class.
+  if (e instanceof FrameUnchecked || (e instanceof Error && e.name === "FrameUnchecked")) return (e as FrameUnchecked).file;
+  const err = e as { code?: string; path?: string } | null;
+  if (err && err.code === "ENOENT" && typeof err.path === "string" && missedPaths.has(resolve(err.path))) return err.path.slice(out.length + 1);
+  return null;
+}
+try {
+  await desc!.check(run, t);
+} catch (e) {
+  const frame = missedFrame(e);
+  if (frame !== null) notes.push(`the check read ${frame}, a frame taken without a renderer, and stopped there: the checks after it did not run (put frame checks in t.frame so every other check runs)`);
+  else failures.push(`check threw: ${e instanceof Error ? e.message : String(e)}`);
+}
+finish();

package/src/node/png.ts

@@ -0,0 +1,130 @@
+// PNG frames: the probe's captures decoded (8-bit RGB or RGBA,
+// non-interlaced, any filter) and RGBA images encoded (`og polish` writes
+// its report's frames at half size).
+import { deflateSync, inflateSync } from "node:zlib";
+
+export interface Image {
+  width: number;
+  height: number;
+  /** RGBA8 rows. */
+  rgba: Uint8Array;
+}
+
+/** An 8-bit RGB or RGBA, non-interlaced PNG, unfiltered. */
+export function decodePng(bytes: Uint8Array): Image {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let at = 8;
+  let width = 0;
+  let height = 0;
+  let channels = 4;
+  const idat: Uint8Array[] = [];
+  while (at < bytes.length) {
+    const len = view.getUint32(at);
+    const type = String.fromCharCode(...bytes.subarray(at + 4, at + 8));
+    const data = bytes.subarray(at + 8, at + 8 + len);
+    if (type === "IHDR") {
+      width = view.getUint32(at + 8);
+      height = view.getUint32(at + 12);
+      const depth = data[8]!;
+      const color = data[9]!;
+      if (depth !== 8 || (color !== 6 && color !== 2) || data[12] !== 0) throw new Error(`unsupported PNG (depth ${depth}, colour ${color}, interlace ${data[12]})`);
+      channels = color === 6 ? 4 : 3;
+    } else if (type === "IDAT") idat.push(data);
+    else if (type === "IEND") break;
+    at += 12 + len;
+  }
+  const joined = new Uint8Array(idat.reduce((n, d) => n + d.length, 0));
+  idat.reduce((at, d) => (joined.set(d, at), at + d.length), 0);
+  const raw = inflateSync(joined);
+  const stride = width * channels;
+  const out = new Uint8Array(width * height * 4);
+  const prev = new Uint8Array(stride);
+  const cur = new Uint8Array(stride);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)]!;
+    const line = raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
+    for (let i = 0; i < stride; i++) {
+      const a = i >= channels ? cur[i - channels]! : 0;
+      const b = prev[i]!;
+      const c = i >= channels ? prev[i - channels]! : 0;
+      let v = line[i]!;
+      if (filter === 1) v += a;
+      else if (filter === 2) v += b;
+      else if (filter === 3) v += (a + b) >> 1;
+      else if (filter === 4) {
+        const p = a + b - c;
+        const pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
+        v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+      }
+      cur[i] = v & 255;
+    }
+    for (let x = 0; x < width; x++) {
+      for (let k = 0; k < 4; k++) out[(y * width + x) * 4 + k] = k < channels ? cur[x * channels + k]! : 255;
+    }
+    prev.set(cur);
+  }
+  return { width, height, rgba: out };
+}
+
+/** Half the size, each pixel the mean of four. */
+export function half(img: Image): Image {
+  const width = Math.max(1, img.width >> 1);
+  const height = Math.max(1, img.height >> 1);
+  const rgba = new Uint8Array(width * height * 4);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      for (let k = 0; k < 4; k++) {
+        const at = (sx: number, sy: number) => img.rgba[(Math.min(sy, img.height - 1) * img.width + Math.min(sx, img.width - 1)) * 4 + k]!;
+        rgba[(y * width + x) * 4 + k] = (at(2 * x, 2 * y) + at(2 * x + 1, 2 * y) + at(2 * x, 2 * y + 1) + at(2 * x + 1, 2 * y + 1) + 2) >> 2;
+      }
+    }
+  }
+  return { width, height, rgba };
+}
+
+const CRC = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+
+function chunk(type: string, data: Uint8Array): Uint8Array {
+  const out = new Uint8Array(12 + data.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, data.length);
+  for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i);
+  out.set(data, 8);
+  let c = 0xffffffff;
+  for (let i = 4; i < 8 + data.length; i++) c = CRC[(c ^ out[i]!) & 255]! ^ (c >>> 8);
+  view.setUint32(8 + data.length, (c ^ 0xffffffff) >>> 0);
+  return out;
+}
+
+/** An RGB PNG of the image (alpha dropped), rows filtered with Sub. */
+export function encodePng(img: Image): Uint8Array {
+  const stride = img.width * 3;
+  const raw = new Uint8Array((stride + 1) * img.height);
+  for (let y = 0; y < img.height; y++) {
+    raw[y * (stride + 1)] = 1;
+    for (let x = 0; x < img.width; x++) {
+      for (let k = 0; k < 3; k++) {
+        const v = img.rgba[(y * img.width + x) * 4 + k]!;
+        const left = x > 0 ? img.rgba[(y * img.width + x - 1) * 4 + k]! : 0;
+        raw[y * (stride + 1) + 1 + x * 3 + k] = (v - left) & 255;
+      }
+    }
+  }
+  const ihdr = new Uint8Array(13);
+  const v = new DataView(ihdr.buffer);
+  v.setUint32(0, img.width);
+  v.setUint32(4, img.height);
+  ihdr.set([8, 2, 0, 0, 0], 8);
+  const parts = [new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), chunk("IHDR", ihdr), chunk("IDAT", deflateSync(raw, { level: 9 })), chunk("IEND", new Uint8Array(0))];
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  parts.reduce((at, p) => (out.set(p, at), at + p.length), 0);
+  return out;
+}