dotframe 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.8
+
+From dogfood round 7 (Craft Ones on 0.1.7).
+
+- `doctor` sim:math skips files marked `// dotframe-allow-math-file`, for render-only files the sim reaches because it builds the renderer.
+- `deploy init` pins images: bun from `packageManager` (game or repo root, else the local bun) and the relay's dotframe from the version installed in the game.
+- The vendor fix (doctor and native builds) names `DOTFRAME_VENDOR` for reusing an existing vendor dir.
+
 ## 0.1.7
 
 From dogfood rounds 5 and 6 (Craft Ones on iOS, online, and on the VPS).

package/cli/commands/docker.ts

@@ -14,14 +14,38 @@ async function gitRoot(ctx: Ctx, root: string): Promise<string> {
   return r.output.trim();
 }
 
+interface Versions {
+  bun: string;
+  dotframe: string;
+}
+
+// Pinned versions, so an image built tomorrow is the image built today: bun from packageManager (the game's
+// package.json, then the repo root's), else the bun running this CLI; dotframe as installed in the game.
+function versions(gameRoot: string, repo: string): Versions {
+  let bun = Bun.version;
+  for (const dir of [gameRoot, repo]) {
+    const file = join(dir, "package.json");
+    if (!existsSync(file)) continue;
+    const manager = (JSON.parse(readFileSync(file, "utf8")) as { packageManager?: string }).packageManager ?? "";
+    const match = manager.match(/^bun@(\d+\.\d+\.\d+)/);
+    if (match) {
+      bun = match[1];
+      break;
+    }
+  }
+  const installed = join(gameRoot, "node_modules", "dotframe", "package.json");
+  const dotframe = existsSync(installed) ? (JSON.parse(readFileSync(installed, "utf8")) as { version: string }).version : pkg.version;
+  return { bun, dotframe };
+}
+
 // game: the game's path inside the repo ("" at the root); context: the repo root, relative to deploy/.
-function files(config: Config, game: string, out: string, context: string): Record<string, string> {
+function files(config: Config, game: string, out: string, context: string, v: Versions): Record<string, string> {
   const requires = (config.requires ?? []).filter((t: string): boolean => t !== "bun");
   const apt = requires.length > 0 ? `RUN apt-get update && apt-get install -y --no-install-recommends ${requires.join(" ")} && rm -rf /var/lib/apt/lists/*\n` : "";
   const at = game === "" ? "." : game;
   return {
     "Dockerfile.web": `# Static web build of ${config.name}, served by nginx. Generated by dotframe deploy init; edit freely.
-FROM oven/bun:1 AS build
+FROM oven/bun:${v.bun} AS build
 ${apt}WORKDIR /app
 COPY . .
 RUN cd ${at} && bun install --frozen-lockfile && bun node_modules/dotframe/cli/main.ts build web
@@ -32,9 +56,10 @@ COPY --from=build ${join("/app", at, out)} /usr/share/nginx/html
 EXPOSE 80
 `,
     "Dockerfile.relay": `# Netplay relay for ${config.name}: dotframe relay serve. Generated by dotframe deploy init.
-FROM oven/bun:1-alpine
+FROM oven/bun:${v.bun}-alpine
 WORKDIR /app
-RUN bun add dotframe@${pkg.version}
+# The dotframe version the game has installed; bump it together with the game's.
+RUN bun add dotframe@${v.dotframe}
 ENV PORT=8787
 EXPOSE 8787
 CMD ["bun", "node_modules/dotframe/cli/main.ts", "relay", "serve"]
@@ -86,7 +111,7 @@ export async function deployInit(ctx: Ctx, name: string | undefined, provider: s
   const repo = await gitRoot(ctx, config.root);
   const game = relative(repo, config.root);
   // compose.yaml sits in <game>/deploy; the web build context is the repo root, so workspace code is visible.
-  const generated = files(config, game, t.out, relative(join(config.root, DIR), repo) || ".");
+  const generated = files(config, game, t.out, relative(join(config.root, DIR), repo) || ".", versions(config.root, repo));
   const dir = join(config.root, DIR);
   const written = Object.keys(generated).map((f: string): string => join(DIR, f));
   const existing = written.filter((f: string): boolean => existsSync(join(config.root, f)));

package/cli/commands/doctor.ts

@@ -147,8 +147,9 @@ async function renderCheck(sim: Sim, root: string): Promise<Check> {
 }
 
 // Math.sin and friends differ in the last bits between engines and OSes, so simulation code that calls them drifts
-// between netplay peers and breaks replays on another machine. Render code may use them; mark a line with
-// `dotframe-allow-math` to silence it.
+// between netplay peers and breaks replays on another machine. Render code may use them: mark a line with
+// `dotframe-allow-math`, or a whole render-only file with `// dotframe-allow-math-file`. (The sim module builds the
+// renderer for desync's purity check, so render files are reachable and a static scan cannot tell them apart.)
 const NONDETERMINISTIC = /\bMath\.(sin|cos|tan|asin|acos|atan|atan2|sinh|cosh|tanh|asinh|acosh|atanh|exp|expm1|log|log1p|log2|log10|pow|cbrt|hypot)\b|[\w)\]]\s*\*\*\s*[\w(]/;
 
 // The engine's own files (draw2d's arcs, raster2d) are render code, however the game imports them: a vendored
@@ -173,7 +174,9 @@ function mathCheck(simFile: string): Check {
   const engine = new Map<string, boolean>();
   for (const file of importGraph(simFile).files) {
     if (!/\.tsx?$/.test(file) || file.includes(`${sep}node_modules${sep}`) || engineFile(file, engine)) continue;
-    readFileSync(file, "utf8")
+    const text = readFileSync(file, "utf8");
+    if (text.includes("dotframe-allow-math-file")) continue;
+    text
       .split("\n")
       .forEach((line: string, i: number): void => {
         const code = line.replace(/\/\/.*$/, "");
@@ -187,6 +190,6 @@ function mathCheck(simFile: string): Check {
     ok: false,
     warn: true,
     detail: `${hits.length} platform-dependent math call(s) in code the sim reaches: ${shown}`,
-    fix: "use dotframe/src/detmath (dsin, dcos, datan2, dexp, dpow, ...) in simulation code; mark render-only lines with // dotframe-allow-math",
+    fix: "use dotframe/src/detmath (dsin, dcos, datan2, dexp, dpow, ...) in simulation code; mark render-only lines with // dotframe-allow-math, or a render-only file with // dotframe-allow-math-file",
   };
 }

package/cli/native.ts

@@ -46,7 +46,7 @@ export function sdlLibrary(platform: NativePlatform): string {
 }
 
 export function vendorFix(platform: NativePlatform): string {
-  return `dotframe vendor ${platform}`;
+  return `dotframe vendor ${platform} (builds into ~/.dotframe/vendor), or point DOTFRAME_VENDOR at an existing vendor dir such as a dotframe checkout's vendor/`;
 }
 
 const SPECIFIER = /(?:from\s+|import\s*\(\s*|import\s+)(["'])([^"']+)\1/g;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotframe",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "TS-first game engine and agent-first CLI: one codebase for web, Discord, iOS and native binaries",
   "license": "MIT",
   "type": "module",

package/skill-data/export-web/SKILL.md

@@ -29,6 +29,7 @@ dotframe config set targets.web.deploy.compose '"<compose id>"'   # vps compose
 dotframe deploy web --dry-run && dotframe deploy web --yes
 ```
 
+- Images are pinned: bun from `packageManager` (game or repo root, else the local bun) and the relay's dotframe from the version installed in the game. Rerun `deploy init --yes` after bumping either.
 - The web image installs the tools in `requires` (dotframe.json, for example `["ffmpeg"]`) and builds with dotframe; the relay image runs `dotframe relay serve`. The build context is the repo root, so monorepo ports see workspace code.
 - In Dokploy, route the domain's `/` to service `web` (port 80) and `/relay` to service `relay` (port 8787). For Discord, map `/` and `/relay` to that host.
 - Dokploy builds the pushed branch, not your working tree: deploy warns about unpushed or uncommitted work. On failure it returns the build log (through `vps compose logs`).

package/skill-data/ios/SKILL.md

@@ -6,6 +6,7 @@ description: Build and install the iOS target of a dotframe game. Use when build
 
 ```sh
 dotframe vendor ios                  # once per machine: SDL3 (Xcode generator) and wgpu-native for iOS
+# or reuse an existing vendor (a dotframe checkout's vendor/): export DOTFRAME_VENDOR=<path>
 dotframe doctor                      # vendor:ios, ios-runtime (scriptc pack matching the compiler), team placeholder
 dotframe build ios --json            # dist/ios/<Scheme>.app
 dotframe device install ios --dry-run

package/skill-data/netplay/SKILL.md

@@ -43,7 +43,7 @@ Run several seeds and a high latency (474 ms is what a transatlantic relay measu
 
 ## Rules
 
-- Simulation code uses `dotframe/src/detmath` (dsin, dcos, datan2, dexp, dlog, dpow, ...), never `Math.sin` and friends or `**`: those differ in the last bits between engines and operating systems, so peers and replays drift (Craft Ones' replays diverged between macOS and Linux at frame 120). `dotframe doctor` warns about them (`sim:math`); mark render-only lines with `// dotframe-allow-math`. A replay passing on one machine proves nothing about another: run CI on a second OS.
+- Simulation code uses `dotframe/src/detmath` (dsin, dcos, datan2, dexp, dlog, dpow, ...), never `Math.sin` and friends or `**`: those differ in the last bits between engines and operating systems, so peers and replays drift (Craft Ones' replays diverged between macOS and Linux at frame 120). `dotframe doctor` warns about them (`sim:math`); mark render-only lines with `// dotframe-allow-math`, or a whole render-only file with `// dotframe-allow-math-file` (the sim builds the renderer for desync, so render files count as reachable). A replay passing on one machine proves nothing about another: run CI on a second OS.
 - `desync` reports `restoreMs` early vs late; it warns when late restores cost more than twice the early ones (a heuristic for restore that replays from an earlier frame, which passes desync but stalls real rollbacks late in a match).
 - Build checksums from numbers in a fixed order, never from `JSON.stringify`: native builds can order keys differently from JavaScript, so a web peer and a native peer would report false desyncs.