dotframe 0.1.9 → 0.2.0

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, vendor } from "./commands/ship";
+import { build, deploy, device, deviceLogs, relay, vendor } from "./commands/ship";
 import { doctor } from "./commands/doctor";
 import { deployInit } from "./commands/docker";
 import { configCmd } from "./commands/config";
@@ -31,6 +31,7 @@ Build and ship
   relay    serve [--port 8787]          local netplay relay (same protocol as production)
   relay    deploy [--region eze]        gated
   device   install <target>             gated
+  device   logs <target>                newest crash report from the device, summarized
   vendor   <macos|windows>              SDL3 + wgpu-native for native builds (~/.dotframe/vendor)
   doctor   [--fix] [--docker]           toolchain, vendor, links, config, sim render and math
   config   get [key] | set <key> <json>
@@ -74,13 +75,14 @@ Compares checksums every frame and the full inspect() state every --every frames
 Warns when rollbacks exceed the sim's rollbackWindow.
 
   dotframe desync --latency 474ms --jitter 40ms --mash 42 --json`,
-  play: `dotframe play --online [room] [--frames 600] [--seeds 1,2] [--out .dotframe/play] [--json]
+  play: `dotframe play --online [room] [--frames 600] [--seeds 1,2] [--native] [--out .dotframe/play] [--json]
 
 Builds the web target, starts a local relay, and opens two agent-browser sessions on ?room=<room>&relay=...&mash=<seed>
 (one seed per peer from --seeds).
 Waits until both confirm --frames frames, compares their checksums every 30 frames, and saves a screenshot of each.
 The web entry must honor ?room=, ?relay=, ?mash= and publish globalThis.__dotframe: createProbe() and createMasher()
-from dotframe/src/probe do both (templates show it).`,
+from dotframe/src/probe do both (templates show it). --native makes peer 1 the macOS build, which reads DOTFRAME_ROOM,
+DOTFRAME_RELAY, DOTFRAME_MASH and writes its probe to DOTFRAME_PROBE (templates' main.native.ts does).`,
   build: `dotframe build <target> [--release] [--dry-run] [--json]
 
 Runs targets.<target>.steps from dotframe.json, or for a native target ({"native": {"platform": "macos",
@@ -90,14 +92,15 @@ Failures keep the full output in .dotframe/logs and return its path. --release r
   dotframe build web
   dotframe build ios --release`,
   deploy: `dotframe deploy <target> [--prod] [--dry-run] [--yes] [--json]
-dotframe deploy init <target> --provider dokploy [--compose <id>] [--yes]
+dotframe deploy init <target> --provider dokploy [--compose <id>] [--site <dir>] [--path /play/] [--yes]
 
 provider vercel: uploads targets.<target>.out. provider dokploy: redeploys the compose stack (it builds from the
 pushed branch), waits for the result, and on failure returns the build log. Without --yes it stops with
 APPROVAL_REQUIRED (exit 2); show the --dry-run plan to a human first.
 
 init writes deploy/Dockerfile.web (installs "requires" tools, builds with dotframe), deploy/Dockerfile.relay
-(dotframe relay serve), deploy/nginx.conf (no-cache index.html) and deploy/compose.yaml (web at /, relay at /relay).
+(dotframe relay serve), deploy/nginx.conf (no-cache HTML) and deploy/compose.yaml (web at /, relay at /relay).
+--site serves a static folder (a landing page) at / with the game at --path (default /play/ with a site).
 
   dotframe deploy web --prod --dry-run
   dotframe deploy init web --provider dokploy`,
@@ -108,8 +111,11 @@ serve runs the netplay relay locally (PORT env or --port): it pairs two clients
 messages, the protocol connectRelay in dotframe/src/netplay speaks. deploy redeploys the production relay
 (dokploy) or deploys it to a region (fly), gated like deploy.`,
   device: `dotframe device install <target> [--dry-run] [--yes]
+dotframe device logs <target> [--json]
 
-Installs targets.<target>.app on targets.<target>.device with devicectl. Gated like deploy.`,
+install puts the built app on targets.<target>.device with devicectl (gated like deploy). logs copies the newest
+crash report of the app's process from the device into .dotframe/logs and prints the exception, termination and
+the crashed thread's frames (read-only on the device).`,
   vendor: `dotframe vendor <macos|windows> [--dry-run]
 
 Downloads wgpu-native and builds SDL3 for native targets into DOTFRAME_VENDOR (default ~/.dotframe/vendor), which
@@ -123,7 +129,7 @@ symlinks; --docker builds the dokploy web image locally, as the server would.`,
 dotframe config set <key> <json> [--dry-run]
 
 Dotted keys. Values are JSON (strings need inner quotes). set rewrites dotframe.json with 2-space indent and short
-objects and arrays on one line.
+objects and arrays on one line. vendor is per machine: dotframe config set vendor <dir> writes ~/.dotframe/config.json.
 
   dotframe config set targets.web.deploy.scope '"my-team"'`,
   new: `dotframe new <name> [--template fighter|platformer|blank] [--no-install] [--json]
@@ -171,6 +177,9 @@ const { values, positionals } = parseArgs({
     docker: { type: "boolean" },
     online: { type: "boolean" },
     seeds: { type: "string" },
+    site: { type: "string" },
+    native: { type: "boolean" },
+    path: { type: "string" },
     provider: { type: "string" },
     compose: { type: "string" },
   },
@@ -184,14 +193,14 @@ try {
   if (values.version) console.log(pkg.version);
   else if (command && values.help && COMMAND_HELP[command]) console.log(COMMAND_HELP[command]);
   else if (!command || values.help) console.log(HELP);
-  else if (command === "play" && values.online === true) await playOnline(ctx, rest[0], { frames: v.frames, out: v.out, seeds: v.seeds });
+  else if (command === "play" && values.online === true) await playOnline(ctx, rest[0], { frames: v.frames, out: v.out, seeds: v.seeds, native: values.native === true });
   else if (command === "sim") await sim(ctx, v);
   else if (command === "snap") await snap(ctx, v);
   else if (command === "replay" && rest[0] === "record") await record(ctx, rest[1], v);
   else if (command === "replay" && rest[0] === "verify") await verify(ctx, rest.slice(1));
   else if (command === "desync") await desync(ctx, v);
   else if (command === "build") await build(ctx, rest[0], values.release === true);
-  else if (command === "deploy" && rest[0] === "init") await deployInit(ctx, rest[1], v.provider, v.compose);
+  else if (command === "deploy" && rest[0] === "init") await deployInit(ctx, rest[1], v.provider, v.compose, v.site, v.path);
   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 === "relay" && rest[0] === "serve") {
@@ -201,6 +210,7 @@ try {
     await new Promise((): void => {});
   }
   else if (command === "device" && rest[0] === "install") await device(ctx, rest[1] ?? "ios");
+  else if (command === "device" && rest[0] === "logs") await deviceLogs(ctx, rest[1] ?? "ios");
   else if (command === "vendor") await vendor(ctx, rest[0]);
   else if (command === "doctor") await doctor(ctx, values.fix === true, values.docker === true);
   else if (command === "config") await configCmd(ctx, rest);

package/cli/native.ts

@@ -1,7 +1,7 @@
 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";
+import { CliError, type Ctx, exec, home, loadUserConfig, 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, "..");
@@ -16,10 +16,12 @@ export interface NativeTarget {
   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.
+// Vendored SDL3 and wgpu-native: DOTFRAME_VENDOR, else `dotframe config set vendor <dir>`, 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 configured = loadUserConfig().vendor;
+  if (configured) return resolve(home(configured));
   const local = join(ENGINE, "vendor");
   if (existsSync(join(local, "wgpu", platform))) return local;
   return join(homedir(), ".dotframe", "vendor");
@@ -46,7 +48,7 @@ export function sdlLibrary(platform: NativePlatform): string {
 }
 
 export function vendorFix(platform: NativePlatform): string {
-  return `dotframe vendor ${platform} (builds into ~/.dotframe/vendor), or point DOTFRAME_VENDOR at an existing vendor dir such as a dotframe checkout's vendor/`;
+  return `dotframe vendor ${platform} (builds into ~/.dotframe/vendor), or reuse an existing vendor dir such as a dotframe checkout's vendor/: dotframe config set vendor <dir> (once per machine) or DOTFRAME_VENDOR=<dir>`;
 }
 
 const SPECIFIER = /(?:from\s+|import\s*\(\s*|import\s+)(["'])([^"']+)\1/g;
@@ -149,17 +151,18 @@ export function stageGame(root: string, entry: string, tree: string, engineStage
   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[] }> {
+// check: compile the TypeScript only (scriptc --emit ir, no C, no link), for doctor.
+export async function buildNative(ctx: Ctx, root: string, gameName: string, targetName: string, t: NativeTarget, check = false): 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);
+  if (vendor.missing.length > 0 && !check) 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 stage = join(root, ".dotframe", check ? "check" : "native", targetName);
   const logDir = join(root, ".dotframe", "logs");
-  const log = join(logDir, `build-${targetName}.log`);
+  const log = join(logDir, `${check ? "check" : "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);
@@ -179,12 +182,16 @@ export async function buildNative(ctx: Ctx, root: string, gameName: string, targ
   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"];
+  // The WebSocket client is Objective-C on Apple platforms (NSURLSession) and WinHTTP on Windows.
+  const ws = platform === "macos" ? { source: "df_ws_apple.m", flags: ["-fobjc-arc"] } : { source: "df_ws_win.c", flags: [] as string[] };
   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")] },
+    { label: "cc df_ws", argv: [...cc, ...ws.flags, "-c", join(ENGINE, "native", ws.source), ...inc, "-o", join(lib, "df_ws.o")] },
+    { label: "ar libdf_native", argv: [...ar, join(lib, "libdf_native.a"), join(lib, "df_native.o"), join(lib, "df_audio.o"), join(lib, "df_ws.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")];
+  // scriptc validates that listed libraries exist even when it only emits IR, and a check links nothing.
+  ffi.libraries = check ? [] : [join(lib, "libdf_native.a"), join(vendor.dir, sdlLibrary(platform)), 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") {
@@ -195,13 +202,15 @@ export async function buildNative(ctx: Ctx, root: string, gameName: string, targ
   }
   const scriptc = {
     label: "scriptc",
-    argv: ["scriptc", "build", t.entry, "--ffi", join(stage, "ffi.json"), ...(platform === "windows" ? ["--windows-subsystem", "gui"] : []), "-o", binary],
+    argv: check
+      ? ["scriptc", "build", t.entry, "--ffi", join(stage, "ffi.json"), "--emit", "ir", "-o", join(stage, "check.ll")]
+      : ["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]) {
+  for (const step of check ? [scriptc] : [...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}`);

package/native/df_audio.c

@@ -264,3 +264,15 @@ void df_audio_close(void) {
   if (g_lock) SDL_DestroyMutex(g_lock);
   g_lock = NULL;
 }
+
+// One host call for music and volume, because scriptc library mode (iOS) caps a library at 32 callbacks.
+// op 0 plays track a (loop when b != 0) at volume c, 1 stops, 2 pauses (a != 0) or resumes, 3 sets the music volume
+// to a, 4 sets the master volume to a. Returns df_music_play's result for op 0, else 0.
+int32_t df_music(int32_t op, double a, double b, double c) {
+  if (op == 0) return df_music_play((int32_t)a, b != 0, c);
+  if (op == 1) df_music_stop();
+  else if (op == 2) df_music_pause(a != 0);
+  else if (op == 3) df_music_volume(a);
+  else if (op == 4) df_master_volume(a);
+  return 0;
+}

package/native/df_native.c

@@ -2,6 +2,7 @@
 #include <SDL3/SDL.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <webgpu/webgpu.h>
 #include <webgpu/wgpu.h>
@@ -17,8 +18,6 @@
 
 #define DF_MAX_PIPELINES 64
 #define DF_MAX_BUFFERS 1024
-#define DF_MAX_BIND_GROUPS 1024
-#define DF_MAX_TEXTURES 256
 
 enum { DF_USAGE_VERTEX = 1, DF_USAGE_INDEX = 2, DF_USAGE_UNIFORM = 4 };
 enum { DF_PIPELINE_DEPTH = 1, DF_PIPELINE_BLEND = 4 };
@@ -35,13 +34,29 @@ static WGPURenderPipeline g_pipelines[DF_MAX_PIPELINES];
 static int32_t g_pipeline_count;
 static WGPUBuffer g_buffers[DF_MAX_BUFFERS];
 static int32_t g_buffer_count;
-static WGPUBindGroup g_bind_groups[DF_MAX_BIND_GROUPS];
+// Bind groups and textures grow as needed; ids are never reused, so a destroyed id never aliases a new resource.
+static WGPUBindGroup *g_bind_groups;
+// The texture a bind group samples, or -1, so destroying a texture also releases the groups that hold it.
+static int32_t *g_bind_group_textures;
 static int32_t g_bind_group_count;
-static WGPUTexture g_textures[DF_MAX_TEXTURES];
-static WGPUTextureView g_texture_views[DF_MAX_TEXTURES];
-static int32_t g_texture_sizes[DF_MAX_TEXTURES][2];
-static uint8_t g_texture_smooth[DF_MAX_TEXTURES];
+static int32_t g_bind_group_capacity;
+static WGPUTexture *g_textures;
+static WGPUTextureView *g_texture_views;
+static int32_t (*g_texture_sizes)[2];
+static uint8_t *g_texture_smooth;
 static int32_t g_texture_count;
+static int32_t g_texture_capacity;
+
+// Grows a parallel array to hold at least `need` elements; returns 0 when memory runs out.
+static int grow(void **array, int32_t *capacity, int32_t need, size_t size) {
+  if (need <= *capacity) return 1;
+  int32_t next = *capacity > 0 ? *capacity : 64;
+  while (next < need) next *= 2;
+  void *grown = realloc(*array, (size_t)next * size);
+  if (!grown) return 0;
+  *array = grown;
+  return 1;
+}
 static WGPUSampler g_sampler;
 static WGPUSampler g_sampler_linear;
 static WGPUTexture g_depth_texture;
@@ -292,7 +307,17 @@ void df_buffer_write(int32_t buffer, const uint8_t *data, size_t len) {
 
 // smooth selects linear filtering (fonts, photos) instead of nearest (pixel art).
 int32_t df_texture(int32_t width, int32_t height, const uint8_t *rgba, size_t len, uint8_t smooth) {
-  if (g_texture_count >= DF_MAX_TEXTURES || width <= 0 || height <= 0) return -1;
+  if (width <= 0 || height <= 0) return -1;
+  int32_t capacity = g_texture_capacity;
+  int32_t need = g_texture_count + 1;
+  if (!grow((void **)&g_textures, &capacity, need, sizeof *g_textures)) return -4;
+  capacity = g_texture_capacity;
+  if (!grow((void **)&g_texture_views, &capacity, need, sizeof *g_texture_views)) return -4;
+  capacity = g_texture_capacity;
+  if (!grow((void **)&g_texture_sizes, &capacity, need, sizeof *g_texture_sizes)) return -4;
+  capacity = g_texture_capacity;
+  if (!grow((void **)&g_texture_smooth, &capacity, need, sizeof *g_texture_smooth)) return -4;
+  g_texture_capacity = capacity;
   if (len < (size_t)width * (size_t)height * 4) return -2;
   WGPUTextureDescriptor desc = WGPU_TEXTURE_DESCRIPTOR_INIT;
   desc.usage = WGPUTextureUsage_TextureBinding | WGPUTextureUsage_CopyDst;
@@ -324,6 +349,21 @@ int32_t df_image(const uint8_t *png, size_t len, uint8_t smooth) {
   return id;
 }
 
+// Releases a texture and every bind group that samples it. The id stays retired.
+void df_texture_destroy(int32_t texture) {
+  if (texture < 0 || texture >= g_texture_count || !g_textures[texture]) return;
+  for (int32_t i = 0; i < g_bind_group_count; i++) {
+    if (g_bind_group_textures[i] == texture && g_bind_groups[i]) {
+      wgpuBindGroupRelease(g_bind_groups[i]);
+      g_bind_groups[i] = NULL;
+    }
+  }
+  wgpuTextureViewRelease(g_texture_views[texture]);
+  wgpuTextureRelease(g_textures[texture]);
+  g_texture_views[texture] = NULL;
+  g_textures[texture] = NULL;
+}
+
 // axis 0 width, 1 height.
 int32_t df_texture_size(int32_t texture, int32_t axis) {
   return texture >= 0 && texture < g_texture_count ? g_texture_sizes[texture][axis ? 1 : 0] : 0;
@@ -397,7 +437,13 @@ int32_t df_pipeline(const uint8_t *wgsl, size_t wgsl_len, uint32_t stride, const
 // Pass -1 for a resource the shader does not declare.
 int32_t df_bind(int32_t pipeline, int32_t buffer, int32_t texture) {
   if (pipeline < 0 || pipeline >= g_pipeline_count) return -1;
-  if (g_bind_group_count >= DF_MAX_BIND_GROUPS) return -2;
+  int32_t capacity = g_bind_group_capacity;
+  if (!grow((void **)&g_bind_groups, &capacity, g_bind_group_count + 1, sizeof *g_bind_groups)) return -2;
+  capacity = g_bind_group_capacity;
+  if (!grow((void **)&g_bind_group_textures, &capacity, g_bind_group_count + 1, sizeof *g_bind_group_textures)) return -2;
+  g_bind_group_capacity = capacity;
+  // A destroyed texture cannot be bound again.
+  if (texture >= 0 && texture < g_texture_count && !g_textures[texture]) return -3;
   WGPUBindGroupEntry entries[3];
   size_t count = 0;
   if (buffer >= 0 && buffer < g_buffer_count) {
@@ -424,6 +470,7 @@ int32_t df_bind(int32_t pipeline, int32_t buffer, int32_t texture) {
   WGPUBindGroup group = wgpuDeviceCreateBindGroup(g_device, &desc);
   wgpuBindGroupLayoutRelease(desc.layout);
   g_bind_groups[g_bind_group_count] = group;
+  g_bind_group_textures[g_bind_group_count] = texture >= 0 && texture < g_texture_count ? texture : -1;
   return g_bind_group_count++;
 }
 
@@ -554,6 +601,8 @@ int32_t df_begin(double r, double g, double b, uint8_t use_depth) {
 void df_draw(int32_t pipeline, int32_t bind_group, int32_t vertex_buffer, int32_t index_buffer, uint32_t first,
              uint32_t count) {
   if (!g_frame_pass || pipeline < 0 || pipeline >= g_pipeline_count) return;
+  // A group released with its texture draws nothing rather than sampling freed memory.
+  if (bind_group >= 0 && bind_group < g_bind_group_count && !g_bind_groups[bind_group]) return;
   wgpuRenderPassEncoderSetPipeline(g_frame_pass, g_pipelines[pipeline]);
   if (bind_group >= 0 && bind_group < g_bind_group_count)
     wgpuRenderPassEncoderSetBindGroup(g_frame_pass, 0, g_bind_groups[bind_group], 0, NULL);
@@ -586,13 +635,21 @@ void df_audio_close(void);
 
 void df_close(void) {
   df_audio_close();
-  for (int32_t i = 0; i < g_bind_group_count; i++) wgpuBindGroupRelease(g_bind_groups[i]);
+  for (int32_t i = 0; i < g_bind_group_count; i++)
+    if (g_bind_groups[i]) wgpuBindGroupRelease(g_bind_groups[i]);
+  free(g_bind_groups);
+  free(g_bind_group_textures);
   for (int32_t i = 0; i < g_buffer_count; i++)
     if (g_buffers[i]) wgpuBufferRelease(g_buffers[i]);
   for (int32_t i = 0; i < g_texture_count; i++) {
+    if (!g_textures[i]) continue;
     wgpuTextureViewRelease(g_texture_views[i]);
     wgpuTextureRelease(g_textures[i]);
   }
+  free(g_textures);
+  free(g_texture_views);
+  free(g_texture_sizes);
+  free(g_texture_smooth);
   if (g_sampler) wgpuSamplerRelease(g_sampler);
   if (g_sampler_linear) wgpuSamplerRelease(g_sampler_linear);
   for (int32_t i = 0; i < g_pipeline_count; i++) wgpuRenderPipelineRelease(g_pipelines[i]);

package/native/df_ws_apple.m

@@ -0,0 +1,197 @@
+// WebSocket client for the native relay transport on macOS and iOS, over NSURLSessionWebSocketTask (TLS included).
+// The game polls from its frame: open, state, send, then next/byte/pop to read a message one byte at a time, since
+// scriptc library mode (iOS) cannot hand C a buffer to fill. Built with ARC.
+#import <Foundation/Foundation.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#endif
+#include <SDL3/SDL.h>
+
+enum { DF_WS_CONNECTING = 0, DF_WS_OPEN = 1, DF_WS_CLOSED = 2, DF_WS_ERROR = 3 };
+
+// DF_WS_DEBUG=1 logs socket events and errors to stderr.
+static void ws_log(NSString *format, ...) {
+  if (!getenv("DF_WS_DEBUG")) return;
+  va_list args;
+  va_start(args, format);
+  NSString *line = [[NSString alloc] initWithFormat:format arguments:args];
+  va_end(args);
+  fprintf(stderr, "df_ws: %s\n", line.UTF8String);
+}
+
+@interface DFSocket : NSObject <NSURLSessionWebSocketDelegate>
+@property(nonatomic, strong) NSURLSession *session;
+@property(nonatomic, strong) NSURLSessionWebSocketTask *task;
+@property(nonatomic, strong) NSMutableArray<NSData *> *inbox;
+@property(atomic) int32_t state;
+@end
+
+@implementation DFSocket
+- (void)receive {
+  __weak DFSocket *weakSelf = self;
+  [self.task receiveMessageWithCompletionHandler:^(NSURLSessionWebSocketMessage *message, NSError *error) {
+    DFSocket *socket = weakSelf;
+    if (!socket) return;
+    if (error) {
+      ws_log(@"receive failed: %@", error);
+      if (socket.state != DF_WS_CLOSED) socket.state = DF_WS_ERROR;
+      return;
+    }
+    NSData *data = message.type == NSURLSessionWebSocketMessageTypeString ? [message.string dataUsingEncoding:NSUTF8StringEncoding] : message.data;
+    @synchronized(socket.inbox) {
+      [socket.inbox addObject:data ?: [NSData data]];
+    }
+    [socket receive];
+  }];
+}
+- (void)URLSession:(NSURLSession *)session webSocketTask:(NSURLSessionWebSocketTask *)webSocketTask didOpenWithProtocol:(NSString *)protocol {
+  ws_log(@"open");
+  self.state = DF_WS_OPEN;
+}
+- (void)URLSession:(NSURLSession *)session webSocketTask:(NSURLSessionWebSocketTask *)webSocketTask didCloseWithCode:(NSURLSessionWebSocketCloseCode)closeCode reason:(NSData *)reason {
+  self.state = DF_WS_CLOSED;
+}
+- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
+  if (error) ws_log(@"task failed: %@", error);
+  if (error && self.state != DF_WS_CLOSED) self.state = DF_WS_ERROR;
+}
+@end
+
+static NSMutableArray *g_sockets;
+
+static DFSocket *socket_at(int32_t handle) {
+  if (!g_sockets || handle < 0 || handle >= (int32_t)g_sockets.count) return nil;
+  id entry = g_sockets[handle];
+  return entry == [NSNull null] ? nil : (DFSocket *)entry;
+}
+
+// Returns a socket id; poll df_ws_state until it is open (1), closed (2) or failed (3).
+static int32_t df_ws_open(const uint8_t *url, size_t len) {
+  @autoreleasepool {
+    if (!g_sockets) g_sockets = [NSMutableArray array];
+    NSString *text = [[NSString alloc] initWithBytes:url length:len encoding:NSUTF8StringEncoding];
+    NSURL *target = text ? [NSURL URLWithString:text] : nil;
+    if (!target) return -1;
+    DFSocket *socket = [DFSocket new];
+    socket.inbox = [NSMutableArray array];
+    socket.state = DF_WS_CONNECTING;
+    socket.session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration] delegate:socket delegateQueue:nil];
+    socket.task = [socket.session webSocketTaskWithURL:target];
+    ws_log(@"connecting to %@", target);
+    [socket.task resume];
+    [socket receive];
+    [g_sockets addObject:socket];
+    return (int32_t)g_sockets.count - 1;
+  }
+}
+
+static int32_t df_ws_state(int32_t handle) {
+  DFSocket *socket = socket_at(handle);
+  return socket ? socket.state : DF_WS_CLOSED;
+}
+
+// Sends one text frame. Returns 0, or -1 when the socket is not open.
+static int32_t df_ws_send(int32_t handle, const uint8_t *data, size_t len) {
+  @autoreleasepool {
+    DFSocket *socket = socket_at(handle);
+    if (!socket || socket.state != DF_WS_OPEN) return -1;
+    NSString *text = [[NSString alloc] initWithBytes:data length:len encoding:NSUTF8StringEncoding];
+    if (!text) return -2;
+    __weak DFSocket *weakSocket = socket;
+    [socket.task sendMessage:[[NSURLSessionWebSocketMessage alloc] initWithString:text] completionHandler:^(NSError *error) {
+      if (error && weakSocket && weakSocket.state != DF_WS_CLOSED) weakSocket.state = DF_WS_ERROR;
+    }];
+    return 0;
+  }
+}
+
+// Length in bytes of the oldest unread message, or -1 when there is none.
+static int32_t df_ws_next(int32_t handle) {
+  DFSocket *socket = socket_at(handle);
+  if (!socket) return -1;
+  @synchronized(socket.inbox) {
+    return socket.inbox.count > 0 ? (int32_t)socket.inbox[0].length : -1;
+  }
+}
+
+// Byte `index` of the oldest unread message, or -1 past its end.
+static int32_t df_ws_byte(int32_t handle, int32_t index) {
+  DFSocket *socket = socket_at(handle);
+  if (!socket) return -1;
+  @synchronized(socket.inbox) {
+    if (socket.inbox.count == 0) return -1;
+    NSData *data = socket.inbox[0];
+    if (index < 0 || (NSUInteger)index >= data.length) return -1;
+    return ((const uint8_t *)data.bytes)[index];
+  }
+}
+
+// Drops the oldest unread message.
+static void df_ws_pop(int32_t handle) {
+  DFSocket *socket = socket_at(handle);
+  if (!socket) return;
+  @synchronized(socket.inbox) {
+    if (socket.inbox.count > 0) [socket.inbox removeObjectAtIndex:0];
+  }
+}
+
+static void df_ws_close(int32_t handle) {
+  DFSocket *socket = socket_at(handle);
+  if (!socket) return;
+  socket.state = DF_WS_CLOSED;
+  [socket.task cancelWithCloseCode:NSURLSessionWebSocketCloseCodeNormalClosure reason:nil];
+  [socket.session invalidateAndCancel];
+  g_sockets[handle] = (id)[NSNull null];
+}
+
+// Shares text (a room link): the system share sheet on iOS, the clipboard on macOS. Returns 1 for the share sheet,
+// 2 for the clipboard, 0 on failure.
+static int32_t df_share(const uint8_t *text, size_t len) {
+  @autoreleasepool {
+    NSString *value = [[NSString alloc] initWithBytes:text length:len encoding:NSUTF8StringEncoding];
+    if (!value) return 0;
+#if TARGET_OS_IPHONE
+    UIViewController *root = nil;
+    for (UIScene *scene in UIApplication.sharedApplication.connectedScenes) {
+      if ([scene isKindOfClass:UIWindowScene.class]) root = ((UIWindowScene *)scene).keyWindow.rootViewController;
+    }
+    if (!root) return SDL_SetClipboardText(value.UTF8String) ? 2 : 0;
+    UIActivityViewController *sheet = [[UIActivityViewController alloc] initWithActivityItems:@[ value ] applicationActivities:nil];
+    // iPad presents the sheet as a popover, which needs an anchor.
+    sheet.popoverPresentationController.sourceView = root.view;
+    sheet.popoverPresentationController.sourceRect = CGRectMake(root.view.bounds.size.width / 2, root.view.bounds.size.height / 2, 1, 1);
+    [root presentViewController:sheet animated:YES completion:nil];
+    return 1;
+#else
+    return SDL_SetClipboardText(value.UTF8String) ? 2 : 0;
+#endif
+  }
+}
+
+// The exported surface is two calls, because scriptc library mode (iOS) caps a library at 32 host callbacks.
+// op 0 opens text as a URL (returns a socket), 1 sends text on handle, 2 shares text.
+int32_t df_ws_text(int32_t op, int32_t handle, const uint8_t *text, size_t len) {
+  if (op == 0) return df_ws_open(text, len);
+  if (op == 1) return df_ws_send(handle, text, len);
+  if (op == 2) return df_share(text, len);
+  return -1;
+}
+
+// op 0 state, 1 length of the next message, 2 byte arg of it, 3 drop it, 4 close.
+int32_t df_ws(int32_t op, int32_t handle, int32_t arg) {
+  if (op == 0) return df_ws_state(handle);
+  if (op == 1) return df_ws_next(handle);
+  if (op == 2) return df_ws_byte(handle, arg);
+  if (op == 3) {
+    df_ws_pop(handle);
+    return 0;
+  }
+  if (op == 4) {
+    df_ws_close(handle);
+    return 0;
+  }
+  return -1;
+}