dotframe 0.1.3 → 0.1.5

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.1.5
+
+- Native builds follow the entry's import graph instead of copying the game folder: relative imports that leave the game root and workspace packages that resolve to source are staged with their relative layout and rewritten to relative paths, so ports inside monorepos compile.
+
+## 0.1.4
+
+Fixes from rounds 2 and 3 of the Craft Ones dogfood.
+
+- Native builds work from the npm package. `build` on a target with `"native": {"platform", "entry"}` stages the engine and the game in `.dotframe/native/<target>`, rewrites `dotframe/...` imports to relative paths, and writes `dist/<target>/<name>`. Templates ship `main.native.ts`, `src/setup.ts`, and macos and windows targets, and compile on both.
+- `dotframe vendor <macos|windows>` puts SDL3 and wgpu-native in `~/.dotframe/vendor` (or `DOTFRAME_VENDOR`), outside `node_modules`. `doctor` checks it per native target.
+- Failed build steps keep the full output in `.dotframe/logs/` and return its path as `error.log`, with the compiler's error count in the message.
+- `doctor` `sim:render` fails when render changes simulation state (checksum or any `inspect()` field), not only when it draws nothing.
+- `sim` and `replay` take `--through-over` to keep stepping after the match ends.
+- `snap` sets the viewport after opening the page and fails with `SNAP_SIZE` when the screenshot does not match the window.
+- Skills: the macos guide covers native targets, vendor, logs, and scriptc-compatible code; core covers `--through-over` and agent-browser sessions; netplay covers `--renders 0`.
+
 ## 0.1.3
 
 Fixes from the Craft Ones port dogfood.

package/cli/commands/doctor.ts

@@ -3,7 +3,8 @@ import { dirname, resolve } from "node:path";
 import { type Config, type Ctx, findRoot, home, loadConfig, print, which } from "../lib";
 import type { Draw2D } from "../../src/draw2d";
 import type { Sim } from "../../src/sim";
-import { headlessRun, loadSim } from "../simkit";
+import { vendorFix, vendorStatus } from "../native";
+import { firstDifference, flatten, headlessRun, loadSim } from "../simkit";
 
 interface Check {
   check: string;
@@ -45,6 +46,13 @@ export async function doctor(ctx: Ctx, fix: boolean): Promise<void> {
         checks.push({ check: `deploy:${name}`, ok: false, detail: "deploy scope is still the template placeholder", fix: `dotframe config set targets.${name}.deploy.scope '"<vercel team>"'`, skill: "export-web" });
       }
     }
+    for (const [name, t] of Object.entries(config.targets)) {
+      if (!t.native) continue;
+      const v = vendorStatus(t.native.platform);
+      checks.push({ check: `vendor:${name}`, ok: v.missing.length === 0, detail: v.missing.length === 0 ? `${v.dir} (${v.sdl})` : `missing in ${v.dir}: ${v.missing.join(", ")}`, fix: v.missing.length === 0 ? "" : vendorFix(t.native.platform), skill: t.native.platform });
+      checks.push(tool("scriptc", "native builds", "npm i -g scriptc", t.native.platform));
+      if (t.native.platform === "windows") checks.push(tool("zig", "windows cross builds", "brew install zig", "macos"));
+    }
     const targets = Object.keys(config.targets);
     if (targets.some((t: string): boolean => t === "web" || t === "discord")) {
       checks.push(tool("vercel", "deploy web", "npm i -g vercel", "export-web"), tool("agent-browser", "dotframe snap", "npm i -g agent-browser && agent-browser install", "core"));
@@ -78,8 +86,9 @@ export async function doctor(ctx: Ctx, fix: boolean): Promise<void> {
   if (failed.length > 0) process.exit(1);
 }
 
-// desync proves rendering is pure by calling render() with a stub Draw2D. A render that draws nothing in that
-// case (for example, one that waits for a real renderer) makes the check pass without checking anything.
+// desync proves rendering is pure by calling render() with a stub Draw2D. Two failure modes are checked here,
+// instantly: a render that draws nothing with the stub (desync's check would be blind), and a render that
+// changes simulation state (checksum or, with inspect(), any field).
 async function renderCheck(sim: Sim, root: string): Promise<Check> {
   const base = { check: "sim:render", skill: "netplay" };
   const run = await headlessRun(sim, root);
@@ -95,9 +104,26 @@ async function renderCheck(sim: Sim, root: string): Promise<Check> {
     },
   });
   run.start(1, { ...sim.options });
-  for (let f = 0; f < 30; f++) run.step(new Array(sim.players).fill(sim.neutral));
-  run.render(draw);
-  return calls > 0
-    ? { ...base, ok: true, detail: `render() drew ${calls} calls with a stub Draw2D`, fix: "" }
-    : { ...base, ok: false, detail: "render() made no draw calls with a stub Draw2D, so desync never exercises it", fix: "render with whatever Draw2D it is given; do not skip when platform.draw is missing" };
+  let next = 1;
+  const random = (): number => {
+    next = (Math.imul(next, 1103515245) + 12345) >>> 0;
+    return next / 4294967296;
+  };
+  // Mashed inputs, so effects, projectiles, and HUD state exist when render runs.
+  let impure = "";
+  for (let f = 0; f < 3000 && impure === "" && !run.over(); f++) {
+    run.step(Array.from({ length: sim.players }, (): number => sim.random(random)));
+    if (f % 10 !== 0) continue;
+    const sum = run.checksum();
+    const before = run.inspect ? flatten(run.inspect()) : null;
+    run.render(draw);
+    if (run.checksum() !== sum) impure = `frame ${f}: checksum changed`;
+    else if (before && run.inspect) {
+      const diff = firstDifference(before, flatten(run.inspect()));
+      if (diff) impure = `frame ${f}: ${diff}`;
+    }
+  }
+  if (calls === 0) return { ...base, ok: false, detail: "render() made no draw calls with a stub Draw2D, so desync never exercises it", fix: "render with whatever Draw2D it is given; do not skip when platform.draw is missing" };
+  if (impure) return { ...base, ok: false, detail: `render() changed simulation state at ${impure}`, fix: "move that write into step(); render must only read", skill: "netplay" };
+  return { ...base, ok: true, detail: `render() drew ${calls} calls with a stub Draw2D and left state unchanged${run.inspect ? "" : " (checksum only; add inspect() for every field)"}`, fix: "" };
 }

package/cli/commands/new.ts

@@ -54,7 +54,7 @@ export async function dev(ctx: Ctx, port: number): Promise<void> {
   const t = target(config, "web");
   if (!t.out) throw new CliError("NO_OUT", "the web target needs an out dir", "", "export-web");
   const out = resolve(config.root, t.out);
-  await runSteps(ctx, config.root, t.steps, "export-web");
+  await runSteps(ctx, config.root, t.steps ?? [], "export-web");
   const server = Bun.serve({
     port,
     fetch: (req: Request): Response => {
@@ -72,7 +72,7 @@ export async function dev(ctx: Ctx, port: number): Promise<void> {
     if (!file || /(^|\/)(node_modules|dist|\.dotframe|\.git)\//.test(`${file}/`) || file.startsWith(t.out ?? "dist")) return;
     if (pending) clearTimeout(pending);
     pending = setTimeout((): void => {
-      runSteps(ctx, config.root, t.steps, "export-web").then(
+      runSteps(ctx, config.root, t.steps ?? [], "export-web").then(
         (): void => console.error(`rebuilt (${file})`),
         (e: unknown): void => console.error(e instanceof Error ? e.message : e),
       );

package/cli/commands/play.ts

@@ -12,6 +12,8 @@ export interface PlayArgs {
   seed?: string;
   options?: string;
   every?: string;
+  // Keep stepping after over(), for rematch and results flows.
+  throughOver?: boolean;
 }
 
 interface Played {
@@ -23,11 +25,11 @@ interface Played {
   ms: number;
 }
 
-function play(run: SimRun, source: InputSource, frames: number, every: number): Played {
+function play(run: SimRun, source: InputSource, frames: number, every: number, throughOver = false): Played {
   const t0 = performance.now();
   const trace: { frame: number; checksum: number }[] = [];
   let f = 0;
-  for (; f < frames && !run.over(); f++) {
+  for (; f < frames && (throughOver || !run.over()); f++) {
     run.step(source.at(f));
     if (every > 0 && (f + 1) % every === 0) trace.push({ frame: f + 1, checksum: run.checksum() });
   }
@@ -47,7 +49,7 @@ async function setup(args: PlayArgs): Promise<{ sim: Sim; run: SimRun; source: I
 
 export async function sim(ctx: Ctx, args: PlayArgs): Promise<void> {
   const { run, source, seed } = await setup(args);
-  const r = play(run, source, num("frames", args.frames, 600, 1), num("every", args.every, 0));
+  const r = play(run, source, num("frames", args.frames, 600, 1), num("every", args.every, 0), args.throughOver === true);
   print(ctx, { seed, inputs: source.describe, ...r }, (): string =>
     [`${r.frames} frames in ${r.ms} ms (${source.describe}, seed ${seed})${r.over ? ", match over" : ""}`, `checksum ${r.checksum}`, JSON.stringify(r.state, null, 2)].join("\n"),
   );
@@ -60,6 +62,7 @@ interface Replay {
   // Encoded inputs as change points.
   inputs: { frame: number; inputs: number[] }[];
   frames: number;
+  throughOver?: boolean;
   checksums: { frame: number; checksum: number }[];
   final: number;
 }
@@ -68,14 +71,14 @@ export async function record(ctx: Ctx, file: string, args: PlayArgs): Promise<vo
   if (!file) throw new CliError("MISSING_ARG", "replay record needs an output file", "dotframe replay record replays/smoke.json --mash 7 --frames 1800");
   const { run, source, seed, options } = await setup(args);
   const frames = num("frames", args.frames, 1800, 1);
-  const r = play(run, source, frames, 60);
+  const r = play(run, source, frames, 60, args.throughOver === true);
   const inputs: Replay["inputs"] = [];
   for (let f = 0; f < r.frames; f++) {
     const cur = source.at(f);
     const last = inputs[inputs.length - 1];
     if (!last || last.inputs.some((v: number, i: number): boolean => v !== cur[i])) inputs.push({ frame: f, inputs: cur.slice() });
   }
-  const replay: Replay = { version: 1, seed, options, inputs, frames: r.frames, checksums: r.trace, final: r.checksum };
+  const replay: Replay = { version: 1, seed, options, inputs, frames: r.frames, ...(args.throughOver ? { throughOver: true } : {}), checksums: r.trace, final: r.checksum };
   writeFileSync(resolve(process.cwd(), file), `${JSON.stringify(replay)}\n`);
   print(ctx, { file, frames: r.frames, final: r.checksum, checkpoints: r.trace.length }, (): string => `recorded ${r.frames} frames to ${file} (final checksum ${r.checksum})`);
 }
@@ -102,7 +105,7 @@ export async function verify(ctx: Ctx, files: string[]): Promise<void> {
         return cur;
       },
     };
-    const r = play(run, source, replay.frames, 60);
+    const r = play(run, source, replay.frames, 60, replay.throughOver === true);
     const mismatch = replay.checksums.find((c, i): boolean => r.trace[i]?.checksum !== c.checksum);
     results.push({ file, ok: !mismatch && r.checksum === replay.final, firstMismatch: mismatch ? mismatch.frame : r.checksum === replay.final ? null : r.frames, expected: replay.final, got: r.checksum });
   }

package/cli/commands/ship.ts

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { buildNative, ENGINE, type NativePlatform, vendorDir, vendorStatus } from "../native";
 import { CliError, type Command, type Ctx, exec, gate, loadConfig, print, runSteps, target, which } from "../lib";
 
 const skillFor = (t: string): string => (t === "web" ? "export-web" : t);
@@ -24,7 +25,14 @@ export async function build(ctx: Ctx, name: string | undefined, release: boolean
     const blocked = licenseBlockers(config.root, config.assets?.localOnly ?? []);
     if (blocked.length > 0) throw new CliError("ASSETS_LOCAL_ONLY", `release build would ship assets marked local-only: ${blocked.join(", ")}`, "replace them with licensed assets, then remove them from assets.localOnly", "assets");
   }
-  const steps = await runSteps(ctx, config.root, t.steps, skillFor(name));
+  if (t.native) {
+    const r = await buildNative(ctx, config.root, config.name, name, t.native);
+    if (ctx.dryRun) return;
+    print(ctx, { target: name, steps: r.steps.map(({ output: _o, ...s }) => s), artifact: r.binary, log: r.log }, (): string => `artifact: ${r.binary}\nlog: ${r.log}`);
+    return;
+  }
+  if (!t.steps) throw new CliError("BAD_CONFIG", `target "${name}" needs "steps" or "native"`, "see dotframe skills get macos", skillFor(name));
+  const steps = (await runSteps(ctx, config.root, t.steps, skillFor(name))).map(({ output: _o, ...s }) => s);
   const artifact = t.out ?? t.app;
   print(ctx, { target: name, dryRun: ctx.dryRun, steps, artifact: artifact ? resolve(config.root, artifact) : null }, (): string =>
     [...steps.map((s): string => (ctx.dryRun ? s.tail : `ok ${s.label} (${s.ms} ms)`)), artifact ? `artifact: ${artifact}` : ""].filter(Boolean).join("\n"),
@@ -96,3 +104,27 @@ export async function device(ctx: Ctx, name: string): Promise<void> {
   if (r.code !== 0) throw new CliError("INSTALL_FAILED", r.tail, "unlock the phone, trust this Mac, enable Developer Mode", "ios");
   print(ctx, { device: t.device, app, ms: r.ms }, (): string => `installed ${app} on ${t.device}`);
 }
+
+// Downloads wgpu-native and builds SDL3 into the vendor dir (default ~/.dotframe/vendor). Local only, slow once.
+export async function vendor(ctx: Ctx, platform: string | undefined): Promise<void> {
+  if (platform !== "macos" && platform !== "windows") throw new CliError("MISSING_ARG", "vendor needs macos or windows", "dotframe vendor macos", "macos");
+  const p = platform as NativePlatform;
+  const dir = vendorDir(p);
+  const before = vendorStatus(p);
+  if (before.missing.length === 0) {
+    print(ctx, { platform: p, dir, ready: true }, (): string => `vendor for ${p} is ready in ${dir}`);
+    return;
+  }
+  const command = { label: `vendor ${p}`, argv: ["sh", join(ENGINE, "scripts", "vendor.sh"), p], env: { DOTFRAME_VENDOR: dir } };
+  if (ctx.dryRun) {
+    print(ctx, { dryRun: true, platform: p, dir, missing: before.missing }, (): string => `would download and build ${before.missing.join(", ")} into ${dir}`);
+    return;
+  }
+  for (const tool of ["curl", "cmake", "unzip", ...(p === "windows" ? ["zig"] : [])]) {
+    if (!which(tool)) throw new CliError("TOOL_MISSING", `${tool} not found`, `brew install ${tool}`, "macos");
+  }
+  await runSteps(ctx, ENGINE, [command], "macos");
+  const after = vendorStatus(p);
+  if (after.missing.length > 0) throw new CliError("VENDOR_MISSING", `vendor.sh finished but ${after.missing.join(", ")} is still missing`, "", "macos");
+  print(ctx, { platform: p, dir, ready: true }, (): string => `vendor for ${p} ready in ${dir}`);
+}

package/cli/commands/snap.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { CliError, type Ctx, exec, loadConfig, num, print, which } from "../lib";
@@ -67,9 +67,10 @@ run(sim.window, (p) => {
   });
   const ab = (...a: string[]) => exec({ ...ctx, json: true }, config.root, { label: `agent-browser ${a[0]}`, argv: ["agent-browser", "--session", "dotframe-snap", ...a] });
   try {
-    await ab("set", "viewport", String(sim.window.width), String(sim.window.height));
     const opened = await ab("open", `http://localhost:${server.port}/`);
     if (opened.code !== 0) throw new CliError("BROWSER_FAILED", opened.tail, "agent-browser install");
+    // After open: agent-browser's daemon is shared, and a viewport set before open can be lost to another session.
+    await ab("set", "viewport", String(sim.window.width), String(sim.window.height));
     // Loading plus stepping can take a while for long inputs; poll for the marker.
     let result: { frame?: number; checksum?: number; state?: unknown; error?: string } | null = null;
     for (let i = 0; i < 120 && !result; i++) {
@@ -80,8 +81,17 @@ run(sim.window, (p) => {
     }
     if (!result) throw new CliError("SNAP_TIMEOUT", "the page never reported ready after 60 s", "open the page with agent-browser --headed and read the console; WebGPU may be unavailable", "core");
     if (result.error) throw new CliError("SNAP_PAGE_ERROR", result.error, "WebGPU unavailable? try AGENT_BROWSER_ARGS=--enable-unsafe-webgpu", "core");
-    const shot = await ab("screenshot", out);
+    let shot = await ab("screenshot", out);
     if (shot.code !== 0) throw new CliError("BROWSER_FAILED", shot.tail);
+    let size = pngSize(out);
+    if (!matches(size, sim.window)) {
+      await ab("set", "viewport", String(sim.window.width), String(sim.window.height));
+      shot = await ab("screenshot", out);
+      size = pngSize(out);
+    }
+    if (!matches(size, sim.window)) {
+      throw new CliError("SNAP_SIZE", `screenshot is ${size.width}x${size.height}, expected ${sim.window.width}x${sim.window.height} (or a device-pixel multiple)`, "close other agent-browser sessions and retry; check agent-browser session list", "core");
+    }
     print(ctx, { out, ...result }, (): string => `frame ${result?.frame} -> ${out} (checksum ${result?.checksum})`);
   } finally {
     await ab("close");
@@ -89,3 +99,14 @@ run(sim.window, (p) => {
     rmSync(work, { recursive: true, force: true });
   }
 }
+
+// Width and height from a PNG's IHDR chunk.
+function pngSize(path: string): { width: number; height: number } {
+  const head = readFileSync(path).subarray(16, 24);
+  return { width: head.readUInt32BE(0), height: head.readUInt32BE(4) };
+}
+
+function matches(size: { width: number; height: number }, window: { width: number; height: number }): boolean {
+  const scale = size.width / window.width;
+  return Number.isInteger(scale) && scale >= 1 && size.height === window.height * scale;
+}

package/cli/lib.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
 export class CliError extends Error {
@@ -8,6 +8,8 @@ export class CliError extends Error {
     readonly fix = "",
     readonly skill = "core",
     readonly exit = 1,
+    // Full output of a failed step, when it was too long for the message.
+    readonly log = "",
   ) {
     super(message);
   }
@@ -26,10 +28,11 @@ export function print(ctx: Ctx, data: unknown, human: () => string): void {
 
 export function fail(ctx: Ctx, error: unknown): never {
   const e = error instanceof CliError ? error : new CliError("INTERNAL", error instanceof Error ? error.message : String(error));
-  if (ctx.json) console.log(JSON.stringify({ ok: false, error: { code: e.code, message: e.message, fix: e.fix, skill: e.skill } }));
+  if (ctx.json) console.log(JSON.stringify({ ok: false, error: { code: e.code, message: e.message, fix: e.fix, skill: e.skill, ...(e.log ? { log: e.log } : {}) } }));
   else {
     console.error(`error ${e.code}: ${e.message}`);
     if (e.fix) console.error(`fix: ${e.fix}`);
+    if (e.log) console.error(`log: ${e.log}`);
     console.error(`guide: dotframe skills get ${e.skill}`);
   }
   process.exit(e.exit);
@@ -48,7 +51,9 @@ export interface Command {
 }
 
 export interface Target {
-  steps: Command[];
+  steps?: Command[];
+  // Native targets built by the CLI itself (staged engine, vendored SDL3 and wgpu-native).
+  native?: import("./native").NativeTarget;
   out?: string;
   app?: string;
   device?: string;
@@ -106,6 +111,8 @@ export interface RunResult {
   code: number;
   ms: number;
   tail: string;
+  // Everything the command printed; kept out of --json output.
+  output: string;
 }
 
 // Runs a command to completion. Output streams to stderr in human mode and is captured (tail kept) in JSON mode.
@@ -128,21 +135,29 @@ export async function exec(ctx: Ctx, root: string, command: Command): Promise<Ru
   };
   await Promise.all([pump(proc.stdout), pump(proc.stderr)]);
   const code = await proc.exited;
-  const tail = chunks.join("").split("\n").slice(-20).join("\n").trim();
-  return { label: command.label, code, ms: Math.round(performance.now() - t0), tail };
+  const output = chunks.join("");
+  const tail = output.split("\n").slice(-20).join("\n").trim();
+  return { label: command.label, code, ms: Math.round(performance.now() - t0), tail, output };
 }
 
 export async function runSteps(ctx: Ctx, root: string, steps: Command[], skill: string): Promise<RunResult[]> {
   const results: RunResult[] = [];
   for (const step of steps) {
     if (ctx.dryRun) {
-      results.push({ label: step.label, code: 0, ms: 0, tail: `would run: ${step.argv.join(" ")} (cwd ${step.cwd ?? "."})` });
+      results.push({ label: step.label, code: 0, ms: 0, tail: `would run: ${step.argv.join(" ")} (cwd ${step.cwd ?? "."})`, output: "" });
       continue;
     }
     if (!ctx.json) console.error(`> ${step.label}`);
     const r = await exec(ctx, root, step);
     results.push(r);
-    if (r.code !== 0) throw new CliError("STEP_FAILED", `step "${step.label}" exited ${r.code}\n${r.tail}`, "read the output above; dotframe doctor checks the toolchain", skill);
+    if (r.code !== 0) {
+      // The message keeps the tail; the whole output goes to a log an agent can read.
+      const log = join(root, ".dotframe", "logs", `${step.label.replace(/[^a-z0-9]+/gi, "-")}.log`);
+      mkdirSync(dirname(log), { recursive: true });
+      writeFileSync(log, r.output);
+      const count = r.output.match(/(\d+) errors?/)?.[1];
+      throw new CliError("STEP_FAILED", `step "${step.label}" exited ${r.code}${count ? ` with ${count} errors` : ""}; full output in ${log}\n${r.tail}`, `read ${log}; dotframe doctor checks the toolchain`, skill, 1, log);
+    }
   }
   return results;
 }

package/cli/main.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { parseArgs } from "node:util";
 import pkg from "../package.json" with { type: "json" };
-import { build, deploy, device, relay } from "./commands/ship";
+import { build, deploy, device, relay, vendor } from "./commands/ship";
 import { doctor } from "./commands/doctor";
 import { configCmd } from "./commands/config";
 import { desync, record, sim, verify } from "./commands/play";
@@ -25,7 +25,8 @@ Build and ship
   deploy   <target> [--prod]            gated: --yes, preview with --dry-run
   relay    deploy [--region eze]        gated
   device   install <target>             gated
-  doctor   [--fix]                      toolchain, links, config, signing
+  vendor   <macos|windows>              SDL3 + wgpu-native for native builds (~/.dotframe/vendor)
+  doctor   [--fix]                      toolchain, vendor, links, config, sim render
   config   get [key] | set <key> <json>
 
 Project
@@ -38,9 +39,10 @@ Global: --json  --yes  --dry-run  --help  --version`;
 const INPUTS = `Inputs: --mash <seed> (random players) or --inputs f.jsonl (one [p0, p1] per frame, or {"frame": n, "inputs": [...]} held until the next line). --seed <n> seeds the sim, --options '<json>' overrides match options.`;
 
 const COMMAND_HELP: Record<string, string> = {
-  sim: `dotframe sim [--mash <seed> | --inputs f.jsonl] [--frames 600] [--seed 1] [--options json] [--every n] [--json]
+  sim: `dotframe sim [--mash <seed> | --inputs f.jsonl] [--frames 600] [--seed 1] [--options json] [--every n] [--through-over] [--json]
 
-Runs the game headless and prints the final state and checksum. --every n adds a checksum trace.
+Runs the game headless and prints the final state and checksum. It stops when the match is over unless
+--through-over (rematch and results flows). --every n adds a checksum trace.
 ${INPUTS}
 
   dotframe sim --mash 7 --frames 600 --json
@@ -51,7 +53,7 @@ Steps the sim to frame n in a real browser (WebGPU, through agent-browser) and s
 ${INPUTS}
 
   dotframe snap --frame 300 --mash 7 --out /tmp/f300.png`,
-  replay: `dotframe replay record <file> [--mash <seed> | --inputs f.jsonl] [--frames 1800] [--seed 1] [--options json]
+  replay: `dotframe replay record <file> [--mash <seed> | --inputs f.jsonl] [--frames 1800] [--seed 1] [--options json] [--through-over]
 dotframe replay verify <file...>
 
 record stores seed, options, inputs, and a checksum every 60 frames. verify replays them and exits 1 with the
@@ -68,7 +70,9 @@ Warns when rollbacks exceed the sim's rollbackWindow.
   dotframe desync --latency 474ms --jitter 40ms --mash 42 --json`,
   build: `dotframe build <target> [--release] [--dry-run] [--json]
 
-Runs targets.<target>.steps from dotframe.json. --release refuses assets listed in assets.localOnly.
+Runs targets.<target>.steps from dotframe.json, or for a native target ({"native": {"platform": "macos",
+"entry": "main.native.ts"}}) stages the engine and game in .dotframe/native/<target> and writes dist/<target>/<name>.
+Failures keep the full output in .dotframe/logs and return its path. --release refuses assets.localOnly.
 
   dotframe build web
   dotframe build ios --release`,
@@ -84,6 +88,10 @@ Redeploys the netplay relay (dokploy) or deploys it to a region (fly). Gated lik
   device: `dotframe device install <target> [--dry-run] [--yes]
 
 Installs targets.<target>.app on targets.<target>.device with devicectl. Gated like deploy.`,
+  vendor: `dotframe vendor <macos|windows> [--dry-run]
+
+Downloads wgpu-native and builds SDL3 for native targets into DOTFRAME_VENDOR (default ~/.dotframe/vendor), which
+survives reinstalling dotframe and is shared by every game.`,
   doctor: `dotframe doctor [--fix] [--json]
 
 Checks tools, dotframe.json, the sim (loads, renders with a stub Draw2D), placeholders, and vendor links.
@@ -136,11 +144,12 @@ const { values, positionals } = parseArgs({
     template: { type: "string" },
     port: { type: "string" },
     "no-install": { type: "boolean" },
+    "through-over": { type: "boolean" },
   },
 });
 
 const ctx: Ctx = { json: values.json === true, yes: values.yes === true, dryRun: values["dry-run"] === true };
-const v = values as Record<string, string | undefined>;
+const v = { ...(values as Record<string, string | undefined>), throughOver: values["through-over"] === true } as Record<string, string | undefined> & { throughOver: boolean };
 const [command, ...rest] = positionals;
 
 try {
@@ -156,6 +165,7 @@ try {
   else if (command === "deploy") await deploy(ctx, rest[0], values.prod === true);
   else if (command === "relay" && rest[0] === "deploy") await relay(ctx, v.region);
   else if (command === "device" && rest[0] === "install") await device(ctx, rest[1] ?? "ios");
+  else if (command === "vendor") await vendor(ctx, rest[0]);
   else if (command === "doctor") await doctor(ctx, values.fix === true);
   else if (command === "config") await configCmd(ctx, rest);
   else if (command === "skills") await skills(ctx, rest, values.full === true, values.all === true);

package/cli/native.ts

@@ -0,0 +1,211 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { CliError, type Ctx, exec, home, print, type RunResult, which } from "./lib";
+
+// The engine this CLI belongs to: a git checkout or node_modules/dotframe.
+export const ENGINE = resolve(import.meta.dir, "..");
+
+export type NativePlatform = "macos" | "windows";
+
+export interface NativeTarget {
+  platform: NativePlatform;
+  // Entry module, relative to the game root.
+  entry: string;
+  // Binary name; defaults to the game name.
+  name?: string;
+}
+
+// Vendored SDL3 and wgpu-native: DOTFRAME_VENDOR, else a checkout's own vendor/ when it is populated, else a
+// per-user cache that survives reinstalling the package.
+export function vendorDir(platform: NativePlatform): string {
+  if (process.env.DOTFRAME_VENDOR) return resolve(home(process.env.DOTFRAME_VENDOR));
+  const local = join(ENGINE, "vendor");
+  if (existsSync(join(local, "wgpu", platform))) return local;
+  return join(homedir(), ".dotframe", "vendor");
+}
+
+export interface VendorStatus {
+  dir: string;
+  missing: string[];
+  sdl: string | null;
+}
+
+export function vendorStatus(platform: NativePlatform): VendorStatus {
+  const dir = vendorDir(platform);
+  const sdl = existsSync(dir) ? (readdirSync(dir).find((d: string): boolean => d.startsWith("SDL3-")) ?? null) : null;
+  const need = [`wgpu/${platform}/lib/libwgpu_native.a`, `build/sdl-${platform}/libSDL3.a`];
+  const missing = need.filter((p: string): boolean => !existsSync(join(dir, p)));
+  if (!sdl) missing.push("SDL3-<version> (headers)");
+  return { dir, missing, sdl };
+}
+
+export function vendorFix(platform: NativePlatform): string {
+  return `dotframe vendor ${platform}`;
+}
+
+const SPECIFIER = /(?:from\s+|import\s*\(\s*|import\s+)(["'])([^"']+)\1/g;
+const EXTENSIONS = ["", ".ts", ".tsx", ".json", "/index.ts", "/index.tsx"];
+
+function resolveFile(base: string): string | null {
+  const candidates = [base.replace(/\.js$/, ".ts"), base];
+  for (const c of candidates) for (const ext of EXTENSIONS) if (existsSync(c + ext) && statSync(c + ext).isFile()) return realpathSync(c + ext);
+  return null;
+}
+
+// A bare specifier that resolves, through node_modules, to TypeScript source outside node_modules: a workspace
+// package (bun and npm link those). Published packages stay packages.
+function resolveWorkspace(specifier: string, fromDir: string): string | null {
+  const parts = specifier.split("/");
+  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  const sub = parts.slice(name.split("/").length).join("/");
+  for (let dir = fromDir; ; dir = dirname(dir)) {
+    const pkgDir = join(dir, "node_modules", name);
+    if (existsSync(pkgDir)) {
+      const real = realpathSync(pkgDir);
+      if (real.split(sep).includes("node_modules")) return null;
+      if (sub) return resolveFile(join(real, sub));
+      const pkg = JSON.parse(readFileSync(join(real, "package.json"), "utf8")) as Record<string, unknown>;
+      const exp = pkg.exports as Record<string, unknown> | string | undefined;
+      const dot = typeof exp === "string" ? exp : (exp?.["."] as Record<string, string> | string | undefined);
+      const entry = typeof dot === "string" ? dot : (dot?.import ?? dot?.default ?? dot?.types ?? (pkg.module as string) ?? (pkg.main as string) ?? "index.ts");
+      return resolveFile(join(real, entry));
+    }
+    if (dirname(dir) === dir) return null;
+  }
+}
+
+interface Graph {
+  files: string[];
+  // Per file, the specifiers to rewrite and the absolute file each one points at.
+  links: Map<string, Map<string, string>>;
+}
+
+// Every source file the entry reaches: relative imports (including ones that leave the game root) and workspace
+// packages. "dotframe/..." is the engine, staged separately.
+function importGraph(entry: string): Graph {
+  const files: string[] = [];
+  const links = new Map<string, Map<string, string>>();
+  const queue = [realpathSync(entry)];
+  const seen = new Set(queue);
+  while (queue.length > 0) {
+    const file = queue.shift() as string;
+    files.push(file);
+    if (!/\.tsx?$/.test(file)) continue;
+    const map = new Map<string, string>();
+    for (const m of readFileSync(file, "utf8").matchAll(SPECIFIER)) {
+      const spec = m[2];
+      if (spec.startsWith("dotframe/") || spec.startsWith("node:")) continue;
+      const target = spec.startsWith(".") ? resolveFile(resolve(dirname(file), spec)) : resolveWorkspace(spec, dirname(file));
+      if (!target) continue;
+      if (!spec.startsWith(".")) map.set(spec, target);
+      if (!seen.has(target)) {
+        seen.add(target);
+        queue.push(target);
+      }
+    }
+    links.set(file, map);
+  }
+  return { files, links };
+}
+
+function commonDir(paths: string[]): string {
+  let base = dirname(paths[0]);
+  for (const p of paths) while (!(p + sep).startsWith(base === sep ? sep : base + sep)) base = dirname(base);
+  return base;
+}
+
+function rel(fromFile: string, to: string): string {
+  const r = relative(dirname(fromFile), to);
+  return r.startsWith(".") ? r : `./${r}`;
+}
+
+// scriptc's static build takes relative imports only, and treats anything under node_modules as package code for
+// its dynamic engine. Staging copies the engine and every reached game file side by side, keeping their relative
+// layout, and rewrites "dotframe/..." and workspace imports to relative paths.
+function stageGame(root: string, entry: string, tree: string, engineStage: string): string {
+  const graph = importGraph(join(root, entry));
+  const base = commonDir([realpathSync(root) + sep + "x", ...graph.files]);
+  const staged = (file: string): string => join(tree, relative(base, file));
+  for (const file of graph.files) {
+    const to = staged(file);
+    mkdirSync(dirname(to), { recursive: true });
+    let text = readFileSync(file, "utf8");
+    if (/\.tsx?$/.test(file)) {
+      const map = graph.links.get(file) ?? new Map<string, string>();
+      text = text.replace(SPECIFIER, (whole: string, q: string, spec: string): string => {
+        if (spec.startsWith("dotframe/")) return whole.replace(`${q}${spec}${q}`, `${q}${rel(to, join(engineStage, spec.slice("dotframe/".length)))}${q}`);
+        const target = map.get(spec);
+        return target ? whole.replace(`${q}${spec}${q}`, `${q}${rel(to, staged(target)).replace(/\.tsx?$/, "")}${q}`) : whole;
+      });
+    }
+    writeFileSync(to, text);
+  }
+  return join(tree, relative(base, realpathSync(root)));
+}
+
+export async function buildNative(ctx: Ctx, root: string, gameName: string, targetName: string, t: NativeTarget): Promise<{ binary: string; log: string; steps: RunResult[] }> {
+  const platform = t.platform;
+  const skill = platform;
+  const tools = platform === "macos" ? ["clang", "scriptc"] : ["zig", "scriptc"];
+  for (const tool of tools) if (!which(tool)) throw new CliError("TOOL_MISSING", `${tool} not found`, tool === "scriptc" ? "npm i -g scriptc" : tool === "zig" ? "brew install zig" : "xcode-select --install", skill);
+  const vendor = vendorStatus(platform);
+  if (vendor.missing.length > 0) throw new CliError("VENDOR_MISSING", `native ${platform} needs SDL3 and wgpu-native in ${vendor.dir}; missing ${vendor.missing.join(", ")}`, vendorFix(platform), skill);
+
+  const stage = join(root, ".dotframe", "native", targetName);
+  const logDir = join(root, ".dotframe", "logs");
+  const log = join(logDir, `build-${targetName}.log`);
+  const out = join(root, "dist", targetName);
+  const binary = join(out, `${t.name ?? gameName}${platform === "windows" ? ".exe" : ""}`);
+  if (!existsSync(join(root, t.entry))) throw new CliError("ENTRY_MISSING", `native entry ${t.entry} does not exist`, `add ${t.entry} (see the macos skill) or fix targets.${targetName}.native.entry`, skill);
+  if (ctx.dryRun) {
+    print(ctx, { dryRun: true, platform, stage, vendor: vendor.dir, binary }, (): string => `would stage the engine and game in ${stage} and build ${binary}`);
+    return { binary, log, steps: [] };
+  }
+  rmSync(stage, { recursive: true, force: true });
+  mkdirSync(logDir, { recursive: true });
+  mkdirSync(out, { recursive: true });
+  const engineStage = join(stage, "dotframe");
+  cpSync(join(ENGINE, "src"), join(engineStage, "src"), { recursive: true });
+  const gameStage = stageGame(root, t.entry, join(stage, "game"), engineStage);
+
+  const inc = [`-I${join(vendor.dir, vendor.sdl ?? "", "include")}`, `-I${join(vendor.dir, "wgpu", platform, "include")}`];
+  const lib = join(stage, "lib");
+  mkdirSync(lib, { recursive: true });
+  const cc = platform === "macos" ? ["clang", "-O2", "-mmacosx-version-min=14.0"] : ["zig", "cc", "-target", "x86_64-windows-gnu", "-O2"];
+  const ar = platform === "macos" ? ["ar", "rcs"] : ["zig", "ar", "rcs"];
+  const steps = [
+    ...["df_native", "df_audio"].map((unit) => ({ label: `cc ${unit}`, argv: [...cc, "-c", join(ENGINE, "native", `${unit}.c`), ...inc, "-o", join(lib, `${unit}.o`)] })),
+    { label: "ar libdf_native", argv: [...ar, join(lib, "libdf_native.a"), join(lib, "df_native.o"), join(lib, "df_audio.o")] },
+  ];
+  const ffi = JSON.parse(readFileSync(join(ENGINE, "native", `ffi.${platform}.json`), "utf8")) as { libraries: string[] };
+  ffi.libraries = [join(lib, "libdf_native.a"), join(vendor.dir, "build", `sdl-${platform}`, "libSDL3.a"), join(vendor.dir, "wgpu", platform, "lib", "libwgpu_native.a")];
+  writeFileSync(join(stage, "ffi.json"), JSON.stringify(ffi, null, 2));
+  let env: Record<string, string> = {};
+  if (platform === "windows") {
+    // A devDependency of dotframe, so an npm install of dotframe does not bring it; the game can.
+    const pack = [ENGINE, root].map((dir: string): string => join(dir, "node_modules", "@scriptc", "runtime-win32-x64-msvc")).find((p: string): boolean => existsSync(p));
+    if (!pack) throw new CliError("TOOL_MISSING", "the scriptc Windows runtime pack is not installed", "bun add -d @scriptc/runtime-win32-x64-msvc", skill);
+    env = { SCRIPTC_TARGET: "x86_64-windows-gnu", SCRIPTC_RUNTIME_PACK: pack };
+  }
+  const scriptc = {
+    label: "scriptc",
+    argv: ["scriptc", "build", t.entry, "--ffi", join(stage, "ffi.json"), ...(platform === "windows" ? ["--windows-subsystem", "gui"] : []), "-o", binary],
+    cwd: gameStage,
+    env,
+  };
+  const results: RunResult[] = [];
+  const full: string[] = [];
+  for (const step of [...steps, scriptc]) {
+    if (!ctx.json) console.error(`> ${step.label}`);
+    const r = await exec(ctx, root, step);
+    full.push(`> ${step.label}: ${step.argv.join(" ")}\n${r.output}`);
+    writeFileSync(log, full.join("\n"));
+    results.push(r);
+    if (r.code !== 0) {
+      const count = r.output.match(/(\d+) errors?/)?.[1];
+      throw new CliError("STEP_FAILED", `step "${step.label}" exited ${r.code}${count ? ` with ${count} errors` : ""}; full output in ${log}\n${r.tail}`, `read ${log}`, skill, 1, log);
+    }
+  }
+  return { binary, log, steps: results };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotframe",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "TS-first game engine and agent-first CLI: one codebase for web, Discord, iOS and native binaries",
   "license": "MIT",
   "type": "module",
@@ -25,7 +25,8 @@
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
-    "skills"
+    "skills",
+    "vendor/toolchain"
   ],
   "repository": {
     "type": "git",

package/scripts/vendor.sh

@@ -1,11 +1,13 @@
 #!/bin/sh
 # Downloads wgpu-native prebuilts and builds SDL3 static for a target. Usage: scripts/vendor.sh <macos|windows>
+# DOTFRAME_VENDOR picks the directory (the dotframe CLI uses ~/.dotframe/vendor); default is this checkout's vendor/.
 set -e
 target=$1
 root=$(cd "$(dirname "$0")/.." && pwd)
 wgpu_version=v29.0.1.1
 sdl_version=3.4.16
-vendor="$root/vendor"
+vendor=${DOTFRAME_VENDOR:-$root/vendor}
+toolchain="$root/vendor/toolchain"
 mkdir -p "$vendor/build"
 
 case $target in
@@ -28,7 +30,7 @@ fi
 if [ ! -f "$vendor/build/sdl-$target/libSDL3.a" ]; then
   case $target in
     macos) extra="-DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_OSX_DEPLOYMENT_TARGET=14.0" ;;
-    windows) extra="-DCMAKE_TOOLCHAIN_FILE=$vendor/toolchain/zig-windows.cmake" ;;
+    windows) extra="-DCMAKE_TOOLCHAIN_FILE=$toolchain/zig-windows.cmake" ;;
   esac
   cmake -S "$vendor/SDL3-$sdl_version" -B "$vendor/build/sdl-$target" -DCMAKE_BUILD_TYPE=Release \
     -DSDL_SHARED=OFF -DSDL_STATIC=ON -DSDL_TEST_LIBRARY=OFF $extra

package/skill-data/core/SKILL.md

@@ -17,6 +17,12 @@ dotframe is a TypeScript game engine. One codebase runs on the web (WebGPU), in
 
 Never claim a visual change works from the JSON alone. Snap it and look.
 
+`sim` and `replay` stop when `over()` turns true. Pass `--through-over` to keep stepping into results and rematch flows.
+
+## agent-browser
+
+`snap` drives agent-browser in its own session (`dotframe-snap`), writes to an absolute path, and checks the PNG size. When you drive agent-browser yourself, always pass `--session <name>` and absolute output paths: one daemon serves the whole machine, so a relative `screenshot out.png` lands in whatever directory the daemon started in (often another repo), and viewports can leak between sessions.
+
 ## Inputs
 
 - `--mash <seed>`: random mashing players, new input every 6 frames. Good default for smoke tests.

package/skill-data/core/references/errors.md

@@ -8,7 +8,7 @@
 | INPUTS_MISSING / BAD_INPUTS | Inputs file missing or a line has the wrong shape | One JSON array or `{frame, inputs}` per line, one input per player |
 | BAD_OPTIONS | `--options` is not a JSON object | Quote it: `--options '{"stocks": 1}'` |
 | UNKNOWN_TARGET | Target not in dotframe.json | Use a listed target or add one |
-| STEP_FAILED | A build step exited non-zero | Read the step output; `dotframe doctor` |
+| STEP_FAILED | A build step exited non-zero | Read the file in `log` (full output); `dotframe doctor` |
 | ASSETS_LOCAL_ONLY | A release would ship unlicensed assets | See `assets` |
 | APPROVAL_REQUIRED (exit 2) | External action without `--yes` | Show the `--dry-run` plan to the human |
 | DEPLOY_SOURCE_DIR | Deploy dir looks like source (repo root, .git, dotframe.json) | Point `out` at the build folder |
@@ -17,6 +17,10 @@
 | DEPLOY_FAILED / INSTALL_FAILED | Provider command failed | Message carries the provider output |
 | TOOL_MISSING | A required CLI is not installed | `dotframe doctor` lists the install command |
 | SNAP_TIMEOUT / SNAP_PAGE_ERROR / BROWSER_FAILED | The snap page did not report ready | Usually no WebGPU in the browser; see message |
+| BAD_ARG / MISSING_ARG | A flag value is not a valid number or duration, or a required flag is missing | Use the value in `fix` |
+| VENDOR_MISSING | Native build without SDL3 or wgpu-native | `dotframe vendor <platform>` |
+| ENTRY_MISSING | The native entry module does not exist | Add `main.native.ts` or fix `native.entry` |
+| SNAP_SIZE | The screenshot size does not match the game window | Close other agent-browser sessions and retry |
 | UNSUPPORTED | The command does not apply (e.g. desync on a 1-player sim) | |
 | REPLAY_MISSING | Replay file not found | `dotframe replay record` |
 | UNKNOWN_SKILL / UNKNOWN_TEMPLATE / UNKNOWN_COMMAND | Typo | Read the `fix` list |

package/skill-data/macos/SKILL.md

@@ -1,16 +1,45 @@
 ---
 name: macos
-description: Build and run native macOS (and Windows) binaries of a dotframe game with scriptc. Use when compiling natively, benchmarking, or debugging the native backend.
+description: Build and run native macOS (and Windows) binaries of a dotframe game with scriptc. Use when compiling natively, setting up the vendored SDL3 and wgpu-native, reading a native build failure, benchmarking, or debugging the native backend.
 ---
 # macos
 
 ```sh
-dotframe build macos --json
+dotframe vendor macos          # once per machine: wgpu-native + SDL3 into ~/.dotframe/vendor (about 1 minute)
+dotframe doctor                # vendor:<target>, scriptc, zig for windows
+dotframe build macos --json    # dist/macos/<name>
+./dist/macos/<name>            # run from the game root: asset paths are relative to it
 ```
 
-The step runs dotframe's `scripts/build-native.sh macos <entry> <name>`: it compiles the C shim (SDL3 + wgpu-native) and the game with scriptc into one binary with no JavaScript engine. Windows cross-builds with zig (`build-native.sh windows`).
+## Native targets
+
+A target with `"native"` is built by the CLI itself:
+
+```json
+"macos": { "native": { "platform": "macos", "entry": "main.native.ts" } },
+"windows": { "native": { "platform": "windows", "entry": "main.native.ts" } }
+```
+
+The CLI copies the engine (`src/`) and every file the entry reaches into `.dotframe/native/<target>/`: relative imports (including ones that leave the game folder, as in a monorepo port importing `../../packages/shared/src`) and workspace packages that resolve to source (`@my/shared` linked by bun or npm workspaces). It keeps their relative layout, rewrites `dotframe/...` and workspace imports to relative paths, compiles the C shim against the vendored SDL3 and wgpu-native, and runs scriptc. This is why it works from `node_modules`: scriptc treats code under `node_modules` as package code for its dynamic engine and takes only relative imports in a static build, so building in place fails.
+
+- Vendor lives in `DOTFRAME_VENDOR`, else a dotframe git checkout's `vendor/` when populated, else `~/.dotframe/vendor`. It survives reinstalling dotframe and is shared by every game.
+- Output goes to the game's `dist/<target>/`, never into `node_modules`.
+- On failure, `error.log` (and the message) points at `.dotframe/logs/build-<target>.log` with the full compiler output. Read it; the message only carries the tail.
+- Windows cross-builds with zig (`brew install zig`), needs `dotframe vendor windows`, and needs scriptc's Windows runtime pack in the game (`bun add -d @scriptc/runtime-win32-x64-msvc`, about 63 MB, so templates leave it out).
+- A target with `"steps"` instead (like Crafter Smash, which vendors dotframe as a submodule) runs its own scripts.
+
+## Code that compiles natively
+
+scriptc compiles a subset of TypeScript. What tripped the templates:
+
+- No `Object.assign` on an existing object: assign fields one by one.
+- Object spread needs every field to have an earlier source: `{ ...c, taken: false }` over a mapped literal fails; build the records explicitly.
+- Structural types become record copies, so engine backends are plain objects of functions, not classes behind interfaces.
+- Keep native-only code in `main.native.ts`; share the rest (see the templates' `src/setup.ts`).
+
+Run `dotframe build macos` early and after each feature: one scriptc error is a quick fix, ninety are a port.
+
+## Other notes
 
-- Games may need env vars at run time (Crafter Smash: `CHARS=railly,anthony SMASH_ROOT=<repo> DOTFRAME=<repo>/vendor/dotframe`).
 - Benchmarks mean nothing while other processes load the machine. Check `top` first and say what else was running.
 - Hidden or occluded windows skip frames and can spin a core. Keep test windows visible.
-- scriptc compiles a subset of TypeScript: structural types become record copies, so engine backends are plain objects of functions, not classes behind interfaces.

package/skill-data/netplay/SKILL.md

@@ -18,6 +18,8 @@ It runs a reference simulation and two peers over a deterministic simulated link
 - `firstStateDifference`: `{frame, path}` of the first field that differs at a checkpoint (`--every 30`). Catches state the checksum does not cover. Needs `inspect()` in the sim.
 - `rollbacks`, `maxRollbackFrames`: how hard the link worked. With `rollbackWindow` in the sim, `warnings` says when a link needs deeper rollbacks than the game allows (real play would stall).
 
+Long runs: rendering on the stub costs whatever the game's render costs. `--renders 0` speeds desync up but turns off the render purity half of the check; use it for rollback depth or latency sweeps, and keep at least one run with renders. `dotframe doctor` also checks render purity on its own, in about a second.
+
 Run several seeds and a high latency (474 ms is what a transatlantic relay measured). A pass on one seed proves little.
 
 ## Reading a failure

package/templates/_base/dotframe.json

@@ -6,7 +6,9 @@
       "steps": [{ "label": "bundle (hashed)", "argv": ["bun", "scripts/build-web.ts"] }],
       "out": "dist/web",
       "deploy": { "provider": "vercel", "project": "__NAME__", "scope": "__SCOPE__" }
-    }
+    },
+    "macos": { "native": { "platform": "macos", "entry": "main.native.ts" } },
+    "windows": { "native": { "platform": "windows", "entry": "main.native.ts" } }
   },
   "assets": { "localOnly": [] }
 }

package/templates/_base/main.native.ts

@@ -0,0 +1,6 @@
+// Native entry for dotframe build macos|windows. The CLI stages it with the engine and compiles it with scriptc.
+import { run } from "dotframe/src/native/run";
+import { WINDOW } from "./src/game";
+import { createSetup } from "./src/setup";
+
+await run(WINDOW, createSetup());

package/templates/_base/main.web.ts

@@ -1,27 +1,5 @@
-import { createDraw2D } from "dotframe/src/draw2d";
-import type { Frame } from "dotframe/src/gpu";
-import { Key } from "dotframe/src/input";
-import type { Platform } from "dotframe/src/platform";
 import { run } from "dotframe/src/web/run";
-import { createGame, keyInput, PLAYERS, render, step, WINDOW } from "./src/game";
+import { WINDOW } from "./src/game";
+import { createSetup } from "./src/setup";
 
-const STEP = 1 / 60;
-
-await run(WINDOW, ({ gpu, input }: Platform): Frame => {
-  const draw = createDraw2D(gpu, WINDOW.width, WINDOW.height);
-  const game = createGame(Math.floor(Math.random() * 1e9));
-  let simulated = -1;
-  return (time: number): boolean => {
-    if (simulated < 0) simulated = time;
-    // Fixed 60 Hz steps, so the browser plays exactly what dotframe sim simulates.
-    for (let n = 0; simulated + STEP <= time && n < 5; n++) {
-      const keys = [keyInput(input, [Key.A, Key.D, Key.W, Key.J]), keyInput(input, [Key.Left, Key.Right, Key.Up, Key.L])];
-      step(game, keys.slice(0, PLAYERS));
-      simulated += STEP;
-    }
-    draw.begin();
-    render(game, draw);
-    draw.end({ r: 0, g: 0, b: 0 });
-    return true;
-  };
-});
+await run(WINDOW, createSetup());

package/templates/_base/src/setup.ts

@@ -0,0 +1,29 @@
+// Shared by main.web.ts and main.native.ts: fixed 60 Hz steps from the keyboard, then one render per frame.
+import { createDraw2D } from "dotframe/src/draw2d";
+import type { Frame, Setup } from "dotframe/src/gpu";
+import { Key } from "dotframe/src/input";
+import type { Platform } from "dotframe/src/platform";
+import { createGame, keyInput, PLAYERS, render, step, WINDOW } from "./game";
+
+const STEP = 1 / 60;
+
+export function createSetup(): Setup {
+  return ({ gpu, input }: Platform): Frame => {
+    const draw = createDraw2D(gpu, WINDOW.width, WINDOW.height);
+    const game = createGame(Math.floor(Math.random() * 1e9));
+    let simulated = -1;
+    return (time: number): boolean => {
+      if (simulated < 0) simulated = time;
+      // Fixed steps, so every target plays exactly what dotframe sim simulates.
+      for (let n = 0; simulated + STEP <= time && n < 5; n++) {
+        const keys = [keyInput(input, [Key.A, Key.D, Key.W, Key.J]), keyInput(input, [Key.Left, Key.Right, Key.Up, Key.L])];
+        step(game, keys.slice(0, PLAYERS));
+        simulated += STEP;
+      }
+      draw.begin();
+      render(game, draw);
+      draw.end({ r: 0, g: 0, b: 0 });
+      return true;
+    };
+  };
+}

package/templates/_base/tsconfig.json

@@ -9,5 +9,6 @@
     "noEmit": true,
     "skipLibCheck": true
   },
-  "include": ["*.ts", "src", "scripts"]
+  "include": ["*.ts", "src", "scripts"],
+  "exclude": ["main.native.ts"]
 }

package/templates/fighter/game.ts

@@ -88,7 +88,15 @@ export function step(game: Game, inputs: number[]): void {
     if (f.y >= GROUND) f.vy = 0;
     if (f.x < -100 || f.x > WINDOW.width + 100) {
       f.stocks -= 1;
-      Object.assign(f, { ...fighter(WINDOW.width / 2, f.facing), stocks: f.stocks });
+      // Field by field: scriptc compiles records, not Object.assign.
+      f.x = WINDOW.width / 2;
+      f.y = GROUND;
+      f.vx = 0;
+      f.vy = 0;
+      f.damage = 0;
+      f.cooldown = 0;
+      f.stun = 0;
+      f.held = 0;
       if (f.stocks === 0) game.winner = 1 - i;
     }
   });

package/templates/platformer/game.ts

@@ -43,13 +43,9 @@ export interface Game {
 }
 
 export function createGame(_seed: number): Game {
-  const coins = [
-    { x: 220, y: 370 },
-    { x: 470, y: 290 },
-    { x: 720, y: 210 },
-    { x: 480, y: 120 },
-    { x: 880, y: 470 },
-  ].map((c) => ({ ...c, taken: false }));
+  const spots = [220, 370, 470, 290, 720, 210, 480, 120, 880, 470];
+  const coins: { x: number; y: number; taken: boolean }[] = [];
+  for (let i = 0; i < spots.length; i += 2) coins.push({ x: spots[i], y: spots[i + 1], taken: false });
   return { frame: 0, x: 60, y: 500 - SIZE, vx: 0, vy: 0, onGround: true, held: 0, coins, winner: -1 };
 }
 

package/vendor/toolchain/zig-ar.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec zig ar "$@"

package/vendor/toolchain/zig-cc.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec zig cc -target x86_64-windows-gnu "$@"

package/vendor/toolchain/zig-cxx.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec zig c++ -target x86_64-windows-gnu "$@"

package/vendor/toolchain/zig-ranlib.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec zig ranlib "$@"

package/vendor/toolchain/zig-rc.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec zig rc "$@"

package/vendor/toolchain/zig-windows.cmake

@@ -0,0 +1,7 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR x86_64)
+set(CMAKE_C_COMPILER "${CMAKE_CURRENT_LIST_DIR}/zig-cc.sh")
+set(CMAKE_CXX_COMPILER "${CMAKE_CURRENT_LIST_DIR}/zig-cxx.sh")
+set(CMAKE_AR "${CMAKE_CURRENT_LIST_DIR}/zig-ar.sh")
+set(CMAKE_RANLIB "${CMAKE_CURRENT_LIST_DIR}/zig-ranlib.sh")
+set(CMAKE_RC_COMPILER "${CMAKE_CURRENT_LIST_DIR}/zig-rc.sh")