dotframe 0.1.9 → 0.2.0

package/native/df_ws_win.c

@@ -0,0 +1,231 @@
+// WebSocket client for the native relay transport on Windows, over WinHTTP (TLS included). Same surface as
+// df_ws_apple.m: the game polls state, sends text frames, and reads messages one byte at a time. Connecting and
+// receiving run on a worker thread per socket; a critical section guards the inbox.
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+#include <winhttp.h>
+#include <SDL3/SDL.h>
+
+enum { DF_WS_CONNECTING = 0, DF_WS_OPEN = 1, DF_WS_CLOSED = 2, DF_WS_ERROR = 3 };
+
+typedef struct Message {
+  uint8_t *data;
+  int32_t len;
+  struct Message *next;
+} Message;
+
+typedef struct {
+  wchar_t url[2048];
+  HINTERNET session, connection, request, socket;
+  volatile LONG state;
+  CRITICAL_SECTION lock;
+  Message *head, *tail;
+  HANDLE thread;
+} Socket;
+
+#define DF_MAX_SOCKETS 16
+static Socket *g_sockets[DF_MAX_SOCKETS];
+
+static Socket *socket_at(int32_t handle) {
+  return handle >= 0 && handle < DF_MAX_SOCKETS ? g_sockets[handle] : NULL;
+}
+
+static void push(Socket *s, const uint8_t *data, int32_t len) {
+  Message *m = (Message *)calloc(1, sizeof *m);
+  if (!m) return;
+  m->data = (uint8_t *)malloc(len > 0 ? (size_t)len : 1);
+  if (!m->data) {
+    free(m);
+    return;
+  }
+  memcpy(m->data, data, (size_t)len);
+  m->len = len;
+  EnterCriticalSection(&s->lock);
+  if (s->tail) s->tail->next = m;
+  else s->head = m;
+  s->tail = m;
+  LeaveCriticalSection(&s->lock);
+}
+
+static DWORD WINAPI run(LPVOID arg) {
+  Socket *s = (Socket *)arg;
+  URL_COMPONENTS parts;
+  memset(&parts, 0, sizeof parts);
+  parts.dwStructSize = sizeof parts;
+  wchar_t host[256], path[1792];
+  parts.lpszHostName = host;
+  parts.dwHostNameLength = 256;
+  parts.lpszUrlPath = path;
+  parts.dwUrlPathLength = 1792;
+  wchar_t extra[1024];
+  parts.lpszExtraInfo = extra;
+  parts.dwExtraInfoLength = 1024;
+  if (!WinHttpCrackUrl(s->url, 0, 0, &parts)) goto fail;
+  // WinHttpCrackUrl knows ws:// and wss:// only as unknown schemes; decide TLS from the prefix.
+  int secure = wcsncmp(s->url, L"wss://", 6) == 0;
+  INTERNET_PORT port = parts.nPort ? parts.nPort : (secure ? 443 : 80);
+  wchar_t target[2816];
+  _snwprintf(target, 2816, L"%ls%ls", parts.dwUrlPathLength ? path : L"/", parts.dwExtraInfoLength ? extra : L"");
+  s->session = WinHttpOpen(L"dotframe", WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
+  if (!s->session) goto fail;
+  s->connection = WinHttpConnect(s->session, host, port, 0);
+  if (!s->connection) goto fail;
+  s->request = WinHttpOpenRequest(s->connection, L"GET", target, NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, secure ? WINHTTP_FLAG_SECURE : 0);
+  if (!s->request) goto fail;
+  if (!WinHttpSetOption(s->request, WINHTTP_OPTION_UPGRADE_TO_WEB_SOCKET, NULL, 0)) goto fail;
+  if (!WinHttpSendRequest(s->request, WINHTTP_NO_ADDITIONAL_HEADERS, 0, NULL, 0, 0, 0)) goto fail;
+  if (!WinHttpReceiveResponse(s->request, NULL)) goto fail;
+  s->socket = WinHttpWebSocketCompleteUpgrade(s->request, 0);
+  if (!s->socket) goto fail;
+  WinHttpCloseHandle(s->request);
+  s->request = NULL;
+  InterlockedExchange(&s->state, DF_WS_OPEN);
+  // A message can arrive in fragments; collect until a non-fragment buffer type closes it.
+  uint8_t chunk[4096];
+  uint8_t *message = NULL;
+  int32_t length = 0;
+  for (;;) {
+    DWORD read = 0;
+    WINHTTP_WEB_SOCKET_BUFFER_TYPE type;
+    if (WinHttpWebSocketReceive(s->socket, chunk, sizeof chunk, &read, &type) != NO_ERROR) break;
+    if (type == WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE) break;
+    uint8_t *grown = (uint8_t *)realloc(message, (size_t)length + read + 1);
+    if (!grown) break;
+    message = grown;
+    memcpy(message + length, chunk, read);
+    length += (int32_t)read;
+    if (type == WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE || type == WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE) {
+      push(s, message, length);
+      length = 0;
+    }
+  }
+  free(message);
+  if (s->state != DF_WS_CLOSED) InterlockedExchange(&s->state, DF_WS_CLOSED);
+  return 0;
+fail:
+  InterlockedExchange(&s->state, DF_WS_ERROR);
+  return 1;
+}
+
+static int32_t df_ws_open(const uint8_t *url, size_t len) {
+  int32_t handle = -1;
+  for (int32_t i = 0; i < DF_MAX_SOCKETS && handle < 0; i++)
+    if (!g_sockets[i]) handle = i;
+  if (handle < 0) return -1;
+  Socket *s = (Socket *)calloc(1, sizeof *s);
+  if (!s) return -1;
+  int written = MultiByteToWideChar(CP_UTF8, 0, (const char *)url, (int)len, s->url, 2047);
+  if (written <= 0) {
+    free(s);
+    return -1;
+  }
+  s->url[written] = 0;
+  s->state = DF_WS_CONNECTING;
+  InitializeCriticalSection(&s->lock);
+  g_sockets[handle] = s;
+  s->thread = CreateThread(NULL, 0, run, s, 0, NULL);
+  if (!s->thread) s->state = DF_WS_ERROR;
+  return handle;
+}
+
+static int32_t df_ws_state(int32_t handle) {
+  Socket *s = socket_at(handle);
+  return s ? (int32_t)s->state : DF_WS_CLOSED;
+}
+
+static int32_t df_ws_send(int32_t handle, const uint8_t *data, size_t len) {
+  Socket *s = socket_at(handle);
+  if (!s || s->state != DF_WS_OPEN) return -1;
+  return WinHttpWebSocketSend(s->socket, WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE, (void *)data, (DWORD)len) == NO_ERROR ? 0 : -2;
+}
+
+static int32_t df_ws_next(int32_t handle) {
+  Socket *s = socket_at(handle);
+  if (!s) return -1;
+  EnterCriticalSection(&s->lock);
+  int32_t len = s->head ? s->head->len : -1;
+  LeaveCriticalSection(&s->lock);
+  return len;
+}
+
+static int32_t df_ws_byte(int32_t handle, int32_t index) {
+  Socket *s = socket_at(handle);
+  if (!s) return -1;
+  EnterCriticalSection(&s->lock);
+  int32_t value = s->head && index >= 0 && index < s->head->len ? s->head->data[index] : -1;
+  LeaveCriticalSection(&s->lock);
+  return value;
+}
+
+static void df_ws_pop(int32_t handle) {
+  Socket *s = socket_at(handle);
+  if (!s) return;
+  EnterCriticalSection(&s->lock);
+  Message *m = s->head;
+  if (m) {
+    s->head = m->next;
+    if (!s->head) s->tail = NULL;
+  }
+  LeaveCriticalSection(&s->lock);
+  if (m) {
+    free(m->data);
+    free(m);
+  }
+}
+
+static void df_ws_close(int32_t handle) {
+  Socket *s = socket_at(handle);
+  if (!s) return;
+  InterlockedExchange(&s->state, DF_WS_CLOSED);
+  if (s->socket) WinHttpWebSocketClose(s->socket, WINHTTP_WEB_SOCKET_SUCCESS_CLOSE_STATUS, NULL, 0);
+  if (s->thread) {
+    WaitForSingleObject(s->thread, 2000);
+    CloseHandle(s->thread);
+  }
+  if (s->socket) WinHttpCloseHandle(s->socket);
+  if (s->request) WinHttpCloseHandle(s->request);
+  if (s->connection) WinHttpCloseHandle(s->connection);
+  if (s->session) WinHttpCloseHandle(s->session);
+  while (s->head) df_ws_pop(handle);
+  DeleteCriticalSection(&s->lock);
+  free(s);
+  g_sockets[handle] = NULL;
+}
+
+// No share sheet on Windows: the text goes to the clipboard. Returns 2 (clipboard) or 0.
+static int32_t df_share(const uint8_t *text, size_t len) {
+  char *value = (char *)malloc(len + 1);
+  if (!value) return 0;
+  memcpy(value, text, len);
+  value[len] = 0;
+  int ok = SDL_SetClipboardText(value);
+  free(value);
+  return ok ? 2 : 0;
+}
+
+// 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;
+}

package/native/ffi.macos.json

@@ -134,6 +134,14 @@
       ],
       "returns": "i32"
     },
+    {
+      "name": "dfTextureDestroy",
+      "symbol": "df_texture_destroy",
+      "params": [
+        "i32"
+      ],
+      "returns": "void"
+    },
     {
       "name": "dfTextureSize",
       "symbol": "df_texture_size",
@@ -243,49 +251,40 @@
       "returns": "i32"
     },
     {
-      "name": "dfMusicPlay",
-      "symbol": "df_music_play",
-      "params": [
-        "i32",
-        "bool",
-        "f64"
-      ],
-      "returns": "i32"
-    },
-    {
-      "name": "dfMusicStop",
-      "symbol": "df_music_stop",
+      "name": "dfAudioActive",
+      "symbol": "df_audio_active",
       "params": [],
-      "returns": "void"
+      "returns": "i32"
     },
     {
-      "name": "dfMusicPause",
-      "symbol": "df_music_pause",
+      "name": "dfWsText",
+      "symbol": "df_ws_text",
       "params": [
-        "bool"
+        "i32",
+        "i32",
+        "string"
       ],
-      "returns": "void"
+      "returns": "i32"
     },
     {
-      "name": "dfMusicVolume",
-      "symbol": "df_music_volume",
+      "name": "dfWs",
+      "symbol": "df_ws",
       "params": [
-        "f64"
+        "i32",
+        "i32",
+        "i32"
       ],
-      "returns": "void"
+      "returns": "i32"
     },
     {
-      "name": "dfMasterVolume",
-      "symbol": "df_master_volume",
+      "name": "dfMusic",
+      "symbol": "df_music",
       "params": [
+        "i32",
+        "f64",
+        "f64",
         "f64"
       ],
-      "returns": "void"
-    },
-    {
-      "name": "dfAudioActive",
-      "symbol": "df_audio_active",
-      "params": [],
       "returns": "i32"
     }
   ],

package/native/ffi.windows.json

@@ -134,6 +134,14 @@
       ],
       "returns": "i32"
     },
+    {
+      "name": "dfTextureDestroy",
+      "symbol": "df_texture_destroy",
+      "params": [
+        "i32"
+      ],
+      "returns": "void"
+    },
     {
       "name": "dfTextureSize",
       "symbol": "df_texture_size",
@@ -243,49 +251,40 @@
       "returns": "i32"
     },
     {
-      "name": "dfMusicPlay",
-      "symbol": "df_music_play",
-      "params": [
-        "i32",
-        "bool",
-        "f64"
-      ],
-      "returns": "i32"
-    },
-    {
-      "name": "dfMusicStop",
-      "symbol": "df_music_stop",
+      "name": "dfAudioActive",
+      "symbol": "df_audio_active",
       "params": [],
-      "returns": "void"
+      "returns": "i32"
     },
     {
-      "name": "dfMusicPause",
-      "symbol": "df_music_pause",
+      "name": "dfWsText",
+      "symbol": "df_ws_text",
       "params": [
-        "bool"
+        "i32",
+        "i32",
+        "string"
       ],
-      "returns": "void"
+      "returns": "i32"
     },
     {
-      "name": "dfMusicVolume",
-      "symbol": "df_music_volume",
+      "name": "dfWs",
+      "symbol": "df_ws",
       "params": [
-        "f64"
+        "i32",
+        "i32",
+        "i32"
       ],
-      "returns": "void"
+      "returns": "i32"
     },
     {
-      "name": "dfMasterVolume",
-      "symbol": "df_master_volume",
+      "name": "dfMusic",
+      "symbol": "df_music",
       "params": [
+        "i32",
+        "f64",
+        "f64",
         "f64"
       ],
-      "returns": "void"
-    },
-    {
-      "name": "dfAudioActive",
-      "symbol": "df_audio_active",
-      "params": [],
       "returns": "i32"
     }
   ],
@@ -317,6 +316,7 @@
     "dxgi",
     "d3dcompiler_47",
     "propsys",
-    "unwind"
+    "unwind",
+    "winhttp"
   ]
 }

package/package.json

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

package/scripts/build-native.sh

@@ -15,7 +15,9 @@ case $target in
       clang -O2 -c "$root/native/$unit.c" -I"$root/vendor/SDL3-3.4.16/include" -I"$root/vendor/wgpu/macos/include" \
         -mmacosx-version-min=14.0 -o "$root/build/macos/$unit.o"
     done
-    ar rcs "$root/build/macos/libdf_native.a" "$root/build/macos/df_native.o" "$root/build/macos/df_audio.o"
+    clang -O2 -fobjc-arc -c "$root/native/df_ws_apple.m" -I"$root/vendor/SDL3-3.4.16/include" -mmacosx-version-min=14.0 \
+      -o "$root/build/macos/df_ws.o"
+    ar rcs "$root/build/macos/libdf_native.a" "$root/build/macos/df_native.o" "$root/build/macos/df_audio.o" "$root/build/macos/df_ws.o"
     cd "$(dirname "$entry_file")" && scriptc build "$(basename "$entry_file")" --ffi "$root/native/ffi.macos.json" \
       -o "$root/build/macos/$name"
     ;;
@@ -24,7 +26,9 @@ case $target in
       zig cc -target x86_64-windows-gnu -O2 -c "$root/native/$unit.c" -I"$root/vendor/SDL3-3.4.16/include" \
         -I"$root/vendor/wgpu/windows/include" -o "$root/build/windows/$unit.o"
     done
-    zig ar rcs "$root/build/windows/libdf_native.a" "$root/build/windows/df_native.o" "$root/build/windows/df_audio.o"
+    zig cc -target x86_64-windows-gnu -O2 -c "$root/native/df_ws_win.c" -I"$root/vendor/SDL3-3.4.16/include" \
+      -o "$root/build/windows/df_ws.o"
+    zig ar rcs "$root/build/windows/libdf_native.a" "$root/build/windows/df_native.o" "$root/build/windows/df_audio.o" "$root/build/windows/df_ws.o"
     cd "$(dirname "$entry_file")" && SCRIPTC_RUNTIME_PACK="$root/node_modules/@scriptc/runtime-win32-x64-msvc" \
       SCRIPTC_TARGET=x86_64-windows-gnu scriptc build "$(basename "$entry_file")" --ffi "$root/native/ffi.windows.json" \
       --windows-subsystem gui -o "$root/build/windows/$name.exe"

package/skill-data/core/SKILL.md

@@ -60,7 +60,9 @@ Pass `--json` and read `ok`. Errors look like `{"ok": false, "error": {"code", "
 
 - `dotframe/src/detmath`: deterministic sin, cos, tan, atan, atan2, exp, log, pow, hypot for simulation code.
 - `dotframe/src/checksum`: a fixed-order checksum over numbers.
-- `dotframe/src/netplay` and `dotframe/src/relay-client`: rollback netplay and the relay connection (see netplay).
+- `dotframe/src/netplay` and `dotframe/src/relay-client`: rollback netplay and the relay connection (see netplay); `dotframe/src/native/relay` on native.
+- `dotframe/src/ui`: buttons and arrow rows laid out once for drawing and hit-testing (`column`, `hit`, `drawUi`, `moveFocus`), taps from mouse and touch (`createTap`), and `createReleaseGate` so the press that starts a match does not reach gameplay.
+- Web: `run(window, setup, { fit: "window" })` fills the browser window; `Draw2D.resize(w, h)` lets the logical canvas follow `gpu.aspect()`.
 
 ## Other guides
 

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

@@ -24,6 +24,7 @@ dotframe deploy web --prod --yes     # only after the human approved the plan
 
 ```sh
 dotframe deploy init web --provider dokploy     # deploy/Dockerfile.web, Dockerfile.relay, nginx.conf, compose.yaml
+dotframe deploy init web --provider dokploy --site landing   # a static folder at /, the game at /play/ (--path)
 dotframe doctor --docker                        # builds the web image locally, as the server will
 dotframe config set targets.web.deploy.compose '"<compose id>"'   # vps compose list
 dotframe deploy web --dry-run && dotframe deploy web --yes

package/skill-data/ios/SKILL.md

@@ -46,10 +46,15 @@ Templates ship this as `main.ios.ts` over the same `src/setup.ts` web and macOS
 
 ## Notes
 
+- Crash with no message? `dotframe device logs ios` copies the newest crash report from the device and prints the exception and crashed thread. build ios also wraps init and frame so a TypeScript throw prints `dotframe: init threw: <message and stack>` to the device log before scriptc's trap aborts.
+- scriptc library mode caps host callbacks at 32. build ios registers only the df* functions the entry reaches (a game without networking uses 27, with the native relay 29); the glue fails with the list if a game goes over.
+- Textures: native has no fixed cap anymore; free what you replace with `gpu.destroyTexture(texture)` (its id is retired, do not draw it again).
+- Online on iOS: `connectRelayNative` and `shareText` from `dotframe/src/native/relay` (see netplay).
+
 - The scriptc runtime pack (`@scriptc/runtime-ios-arm64`) must match `scriptc --version`. Right after a scriptc release, bun's minimum release age blocks it; doctor prints the install command with `--minimum-release-age 0`.
 - Touches never synthesize a mouse (SDL_HINT_TOUCH_MOUSE_EVENTS is off), so read `input.touches()` for fingers; `input.pointer()` stays the mouse.
 - Size the logical canvas from `gpu.aspect()` (templates do): a 1280x720 canvas on a 2.16 phone stretches otherwise.
-- Library mode has no `WebSocket`; online play is web only for now (`dotframe/src/relay-client` is web only).
+- Library mode has no browser `WebSocket`: use `dotframe/src/native/relay`, not `dotframe/src/relay-client`.
 - Signing is automatic with `team`; a locked password manager can fail signing with `failed to fill whole buffer`: ask the human to unlock it and retry.
 - `build ios --release` refuses assets marked local-only (see `assets`).
 - Confirm on the device by asking the human. A successful install is not a working game.

package/skill-data/macos/SKILL.md

@@ -60,8 +60,15 @@ Runtime traps (compile clean, fail when run):
 
 - **Structural coercion copies.** Passing a class instance, or a wider record, to a parameter typed as a narrower structural type passes a copy: the callee's writes to scalar fields are lost (arrays inside still alias). In Craft Ones every projectile froze mid-flight. Pass the exact type, or return the updated record and copy it back. Reported to scriptc.
 - **Out-of-range reads.** `rows[y - 1]?.[x]` typed as `string` but `undefined` at runtime crashes with "undefined is not representable in the target union". Bounds-check before reading.
+- **Assigning `globalThis`** traps at startup ("expected object at $"). Keep web-only code (probe publishing, DOM) in web-only modules.
+- **Passing a function whose parameter type differs** from the slot traps ("function invoked through a ... slot"): wrap it in a function of the exact type, for example `run(WINDOW, (platform: Platform): Frame => setup(platform))`. Passing a wider object as a direct argument works.
+- **`doctor`'s `native:<target>` check compiles but does not run.** Run the binary after changes; CI runs each template binary for a few seconds for this reason.
 - **`JSON.stringify` key order** differed from JavaScript in Craft Ones (not reproduced in a minimal case). Never build checksums or netplay comparisons from it.
 
+## Networking
+
+`dotframe/src/native/relay` (WebSocket over NSURLSession on macOS and iOS, WinHTTP on Windows). Inside a scriptc executable, hostnames and TLS hang (system services never answer there); IP addresses and localhost connect. `DF_WS_DEBUG=1` logs socket events.
+
 ## Debugging a native crash
 
 `--optimization dev` builds failed to link in Craft Ones (undefined `_main`; a template game links fine). When that happens, debug the release binary with lldb: `lldb ./dist/macos/<name>`, `breakpoint set -n scr_error_new`, `run`, then `bt` shows the TypeScript call site of a runtime error.

package/skill-data/netplay/SKILL.md

@@ -15,7 +15,11 @@ dotframe relay serve                  # local relay on :8787, same protocol as p
 dotframe play --online --frames 900   # two browsers, scripted match, checksums compared, screenshots saved
 ```
 
-`play --online` needs the web entry to honor `?room=`, `?relay=` and `?mash=<seed>` and to publish `globalThis.__dotframe = { frame, confirmed, status, sums }` (sums: checksum per 30th confirmed frame). `dotframe/src/probe` does both: `createProbe()` publishes it (call `probe.update(rollback, link.status())` each step, or `probe.update(null, "local", frame)` offline), and `createMasher(seed, randomInput)` returns a function giving the scripted input for each step. `--seeds 7,42` picks each peer's seed. The templates show the wiring.
+Native builds connect with `dotframe/src/native/relay`: `connectRelayNative(url, room)` returns the same RelayLink, polled from the frame (no promises in library mode). `shareText(text)` opens the share sheet on iOS and copies to the clipboard on macOS and Windows. `play --online --native` makes peer 1 the macOS build (it reads DOTFRAME_ROOM, DOTFRAME_RELAY, DOTFRAME_MASH and writes its probe to DOTFRAME_PROBE; templates do), so a web peer and a native peer must agree on every checksum.
+
+Known limit: inside a scriptc executable (macOS), hostnames and TLS never connect (Network.framework waits on system services that never answer there); IP addresses and localhost work, so local relays and LAN play do. Reported to scriptc. iOS runs as a library under SDL and is not affected the same way; verify on a device.
+
+`play --online` needs the web entry to honor `?room=`, `?relay=` and `?mash=<seed>` and to publish `globalThis.__dotframe = { frame, confirmed, status, sums }` (sums: checksum per 30th confirmed frame). `dotframe/src/probe` does both: `createProbe()` keeps it (call `probe.update(rollback, link.status())` each step, or `probe.update(null, "local", frame)` offline) and `publishProbe(state)` from `dotframe/src/probe-web` exposes it (web only: assigning globalThis traps in scriptc), and `createMasher(seed, randomInput)` returns a function giving the scripted input for each step. `--seeds 7,42` picks each peer's seed. The templates show the wiring.
 
 dotframe online play is rollback netcode: each peer predicts the remote input (repeat the last one), simulates ahead, and when the real input arrives and differs, restores a snapshot and resimulates. It only works if every peer computes bit-identical state from the same inputs.
 

package/src/draw2d.ts

@@ -6,6 +6,8 @@ import { BufferUsage, type Color, type Draw, type RenderGpu, type Texture, Verte
 
 export interface Draw2D {
   begin: () => void;
+  // Changes the logical canvas size (for a window that resizes); coordinates map onto the whole surface.
+  resize: (width: number, height: number) => void;
   end: (clear: Color) => void;
   save: () => void;
   restore: () => void;
@@ -652,6 +654,11 @@ export function createDraw2D(gpu: RenderGpu, width: number, height: number): Dra
   };
 
   return {
+    resize: (w: number, h: number): void => {
+      uniforms[0] = w;
+      uniforms[1] = h;
+      gpu.writeBuffer(uniformBuffer, new Uint8Array(uniforms.buffer, uniforms.byteOffset, uniforms.byteLength));
+    },
     begin: (): void => {
       vertexCount = 0;
       batches.length = 0;

package/src/gpu.ts

@@ -62,6 +62,9 @@ export interface RenderGpu {
   bind: (pipeline: number, buffer: number, texture: number) => number;
   // smooth: linear filtering (fonts, photos); otherwise nearest (pixel art).
   createTexture: (width: number, height: number, rgba: Uint8Array, smooth: boolean) => Texture;
+  // Frees a texture (and, natively, the bind groups sampling it). Its id is never reused; do not draw it again.
+  // Optional so stub GPUs in tests need not implement it.
+  destroyTexture?: (texture: Texture) => void;
   frame: (clear: Color, draws: Draw[]) => void;
   aspect: () => number;
 }

package/src/native/backend.ts

@@ -17,16 +17,13 @@ import {
   dfHeight,
   dfImage,
   dfKeyDown,
-  dfMasterVolume,
   dfMouse,
-  dfMusicPause,
-  dfMusicPlay,
-  dfMusicStop,
-  dfMusicVolume,
   dfPipeline,
+  dfMusic,
   dfPlay,
   dfSound,
   dfTexture,
+  dfTextureDestroy,
   dfTextureSize,
   dfTone,
   dfTouch,
@@ -73,6 +70,7 @@ export function createNativeRenderGpu(): RenderGpu {
       if (id < 0) throw new Error(`dfTexture failed: ${id}`);
       return { id, width, height };
     },
+    destroyTexture: (texture: Texture): void => dfTextureDestroy(texture.id),
     frame: (clear: Color, draws: Draw[]): void => {
       // Pipelines without depth cannot run in a pass with a depth attachment.
       let usesDepth = false;
@@ -129,12 +127,12 @@ export function createNativeAudioPlayer(): AudioPlayer {
     play: (sound: number, volume: number, rate: number): void => dfPlay(sound, volume, rate),
     tone: (frequency: number, duration: number, volume: number): void => dfTone(frequency, duration, volume),
     playMusic: (track: number, loop: boolean, volume: number): void => {
-      dfMusicPlay(track, loop, volume);
+      dfMusic(0, track, loop ? 1 : 0, volume);
     },
-    stopMusic: (): void => dfMusicStop(),
-    pauseMusic: (paused: boolean): void => dfMusicPause(paused),
-    setMusicVolume: (volume: number): void => dfMusicVolume(volume),
-    setMasterVolume: (volume: number): void => dfMasterVolume(volume),
+    stopMusic: (): void => void dfMusic(1, 0, 0, 0),
+    pauseMusic: (paused: boolean): void => void dfMusic(2, paused ? 1 : 0, 0, 0),
+    setMusicVolume: (volume: number): void => void dfMusic(3, volume, 0, 0),
+    setMasterVolume: (volume: number): void => void dfMusic(4, volume, 0, 0),
   };
 }
 

package/src/native/ffi.ts

@@ -14,6 +14,7 @@ export declare function dfPipeline(wgsl: string, stride: number, attributes: Uin
 export declare function dfBind(pipeline: number, buffer: number, texture: number): number;
 export declare function dfTexture(width: number, height: number, rgba: Uint8Array, smooth: boolean): number;
 export declare function dfImage(png: Uint8Array, smooth: boolean): number;
+export declare function dfTextureDestroy(texture: number): void;
 export declare function dfTextureSize(texture: number, axis: number): number;
 export declare function dfPoll(): boolean;
 export declare function dfTouchCount(): number;
@@ -34,9 +35,12 @@ export declare function dfSound(mp3: Uint8Array): number;
 export declare function dfPlay(sound: number, volume: number, rate: number): void;
 export declare function dfTone(frequency: number, duration: number, volume: number): void;
 export declare function dfTrack(mp3: Uint8Array): number;
-export declare function dfMusicPlay(track: number, loop: boolean, volume: number): number;
-export declare function dfMusicStop(): void;
-export declare function dfMusicPause(paused: boolean): void;
-export declare function dfMusicVolume(volume: number): void;
-export declare function dfMasterVolume(volume: number): void;
 export declare function dfAudioActive(): number;
+// Music and volume in one call (library mode caps host callbacks at 32): op 0 play track a, loop when b != 0, at
+// volume c; 1 stop; 2 pause when a != 0, else resume; 3 music volume a; 4 master volume a.
+export declare function dfMusic(op: number, a: number, b: number, c: number): number;
+// WebSocket client and share (df_ws_apple.m, df_ws_win.c), two calls because library mode caps host callbacks at
+// 32. dfWsText: op 0 open url, 1 send text on socket, 2 share text. dfWs: op 0 state, 1 next length, 2 byte, 3 pop,
+// 4 close. See native/relay.ts.
+export declare function dfWsText(op: number, socket: number, text: string): number;
+export declare function dfWs(op: number, socket: number, arg: number): number;