@crowdedkingdoms/crowdyjs 8.17.0 → 8.19.0

package/dist/player-runtime/player-glue-worker.js

@@ -1,127 +1,146 @@
 /**
- * Platform glue worker for browser-target player WASM (player compute P3).
- *
- * This is the ONLY platform code that shares an execution context with an
- * untrusted player module. It runs inside a dedicated Web Worker and is
- * deliberately tiny and auditable:
+ * Browser Web Worker entry for browser-target player WASM (player compute
+ * P3/P5). This is the ONLY platform code that shares an execution context
+ * with an untrusted player module. It is intentionally thin: the auditable
+ * runtime + ABI marshalling live in [glue-runtime.ts] and the synchronous
+ * host-call transport in [glue-sab.ts]; this file only wires them to the
+ * worker message loop.
  *
  *  - it instantiates the gas-injected player artifact with an import table
- *    that exposes ONLY the `ck.*` host functions (every one forwards to the
- *    page-side broker; nothing else is importable),
- *  - it never has the DOM, `window`, auth tokens, `fetch`, or `importScripts`
- *    of third-party code,
- *  - it enforces a per-dispatch wall-clock watchdog and forwards the fuel
- *    budget so a runaway dispatch traps locally (the fuel counter itself is
- *    injected into the artifact by the server compile pipeline),
- *  - it reports traps to the broker, which owns the local circuit breaker.
- *
- * Host calls are synchronous from the guest's perspective. In a worker that
- * is realized with a SharedArrayBuffer control block plus Atomics.wait: the
- * guest's import stub writes the request, wakes the page, and blocks until
- * the broker writes the reply. The message/really-shared plumbing lives in
- * buildImportObject / the init handler below; the pure, testable pieces
- * (budget parsing, host-fn table) are exported.
+ *    that exposes ONLY `ck.*` + inert wasi stubs (nothing else importable),
+ *  - it never has the DOM, `window`, auth tokens, `fetch`, or third-party
+ *    `importScripts`,
+ *  - `ck.host_call` blocks the worker on a SharedArrayBuffer while the
+ *    page-side broker services the (async) server-authorized call and writes
+ *    the reply back, so the guest sees a synchronous gateway,
+ *  - it enforces a per-dispatch wall-clock watchdog and reports traps to the
+ *    broker, which owns the local circuit breaker.
  *
- * This module is bundled to a standalone worker asset; it must not import
- * anything that pulls in the SDK client, DOM types, or Node built-ins.
+ * Re-exports the pure helpers + the runtime so tests and bundlers can use
+ * them without touching worker globals.
  */
-/** The exact host-call names the glue exposes to the guest (mirrors the broker allowlist). */
-export const GLUE_HOST_FUNCTIONS = [
-    'container_create',
-    'container_get',
-    'containers_list',
-    'container_delete',
-    'property_set',
-    'model_invoke',
-    'user_state_get',
-    'user_state_set',
-    'grid_state_get',
-    'grid_state_set',
-    'chunk_get',
-    'voxels_list',
-    'actors_list',
-    'actors_list_radius',
-    'voxel_set',
-    'emit_spatial',
-    'hud_set',
-    'overlay_draw',
-    'grid_permission_check',
-];
-/** Parse the fuel budget the broker forwards; undefined/invalid => unbounded (server still meters). */
-export function parseFuelBudget(raw) {
-    if (raw == null)
-        return null;
-    try {
-        const v = BigInt(raw);
-        return v > 0n ? v : null;
-    }
-    catch {
-        return null;
-    }
-}
+import { GlueRuntime, GLUE_HOST_FUNCTIONS, parseFuelBudget, runWithWatchdog, } from './glue-runtime.js';
+import { createGlueSab, armGlueRequest, waitAndReadGlueReply, } from './glue-sab.js';
+export { GlueRuntime, GLUE_HOST_FUNCTIONS, parseFuelBudget, runWithWatchdog, };
 /**
- * Wrap a single guest dispatch with the wall-clock watchdog. The fuel trap is
- * enforced inside the gas-injected module; this guards against a hang that
- * spins without consuming fuel (e.g. a tight host-call loop the broker rate
- * cap already bounds, belt-and-suspenders). Pure and unit-testable.
+ * Wire the glue runtime to a worker-like message port. Exported (not just
+ * run at import) so the Node integration test can drive the identical wiring
+ * over a `worker_threads` port.
  */
-export async function runWithWatchdog(dispatch, watchdogMs, now = () => Date.now()) {
-    const start = now();
-    try {
-        dispatch();
-    }
-    catch (err) {
-        const message = err.message ?? 'trap';
-        if (/fuel|gas|unreachable/i.test(message)) {
-            return { ok: false, reason: 'fuel', detail: message };
+export function startGlueWorker(port) {
+    let runtime = null;
+    let sab = null;
+    let hostCallId = 0;
+    let watchdogMs = 250;
+    let ticking = false;
+    const post = (message) => port.postMessage(message);
+    // Synchronous gateway: post the request (so the page can see it), then
+    // block on the SAB until the broker writes the reply.
+    const hostCallSync = (reqBytes) => {
+        if (!sab)
+            throw new Error('host-call transport not initialized');
+        let parsed;
+        try {
+            parsed = JSON.parse(new TextDecoder().decode(reqBytes));
         }
-        return { ok: false, reason: 'trap', detail: message };
-    }
-    if (now() - start > watchdogMs) {
-        return { ok: false, reason: 'watchdog' };
-    }
-    return { ok: true };
-}
-/**
- * Build the guest import object. Every entry is a `ck.*` host stub that
- * forwards to the broker; the function set is fixed at build time, so a guest
- * cannot import anything outside GLUE_HOST_FUNCTIONS. `invokeHostCall` is the
- * synchronous bridge (SharedArrayBuffer + Atomics in the browser; injectable
- * for tests).
- */
-export function buildImportObject(invokeHostCall) {
-    const ck = {};
-    for (const fn of GLUE_HOST_FUNCTIONS) {
-        ck[fn] = (argsPtr, argsLen, outPtr) => {
-            // The real ABI marshals argsPtr/argsLen out of guest memory and writes
-            // the reply back at outPtr; the memory plumbing is wired in the init
-            // handler where the instance's memory export is available. This stub
-            // documents the fixed surface and the synchronous forward.
-            void argsPtr;
-            void argsLen;
-            void outPtr;
-            const reply = invokeHostCall(fn, '');
-            return reply.length;
+        catch {
+            throw new Error('host_call request was not valid JSON');
+        }
+        const id = ++hostCallId;
+        armGlueRequest(sab);
+        post({
+            type: 'hostcall',
+            id,
+            fn: parsed.fn,
+            args: parsed.args ?? {},
+            reply: sab.sab,
+        });
+        return waitAndReadGlueReply(sab);
+    };
+    const onInit = async (init) => {
+        watchdogMs = init.watchdogMs ?? 250;
+        void parseFuelBudget(init.fuelPerDispatch);
+        sab = createGlueSab();
+        runtime = new GlueRuntime({
+            hostCallSync,
+            onLog: (level, message) => post({ type: 'log', level, message }),
+        });
+        try {
+            await runtime.instantiate(init.artifact);
+            const initResult = await runWithWatchdog(() => runtime.init(), watchdogMs);
+            report(initResult);
+            if ((init.tickIntervalMs ?? 0) > 0)
+                startTicking(init.tickIntervalMs);
+            post({ type: 'ready' });
+        }
+        catch (err) {
+            post({ type: 'trap', reason: 'trap', detail: err.message });
+        }
+    };
+    const report = (result) => {
+        if (result.ok)
+            post({ type: 'dispatch-ok' });
+        else
+            post({ type: 'trap', reason: result.reason, detail: result.detail });
+    };
+    const startTicking = (intervalMs) => {
+        if (ticking)
+            return;
+        ticking = true;
+        let last = Date.now();
+        const loop = () => {
+            if (!ticking || !runtime)
+                return;
+            const nowT = Date.now();
+            const dt = nowT - last;
+            last = nowT;
+            void runWithWatchdog(() => runtime.tick(dt), watchdogMs).then(report);
+            setTimeout(loop, intervalMs);
         };
+        setTimeout(loop, intervalMs);
+    };
+    const handle = (data) => {
+        if (!data || typeof data !== 'object')
+            return;
+        const msg = data;
+        if (msg.type === 'init')
+            void onInit(msg);
+        else if (msg.type === 'tick' && runtime) {
+            void runWithWatchdog(() => runtime.tick(typeof msg.dtMs === 'number' ? msg.dtMs : 0), watchdogMs).then(report);
+        }
+        else if (msg.type === 'invoke' && runtime) {
+            const payload = msg.payload instanceof Uint8Array ? msg.payload : new Uint8Array(0);
+            try {
+                const out = runtime.invoke(payload);
+                post({ type: 'invoke-result', id: msg.id, ok: true, payload: out });
+            }
+            catch (err) {
+                post({
+                    type: 'invoke-result',
+                    id: msg.id,
+                    ok: false,
+                    error: err.message,
+                });
+            }
+        }
+        else if (msg.type === 'stop') {
+            ticking = false;
+        }
+    };
+    if (port.addEventListener) {
+        port.addEventListener('message', (e) => handle(e.data));
+    }
+    else if (port.on) {
+        port.on('message', (d) => handle(d));
     }
-    return { ck };
 }
+// Auto-start when loaded as a real browser Web Worker (has addEventListener,
+// no window). Guarded so importing for the pure helpers never touches globals.
 if (typeof self !== 'undefined' &&
     typeof self.addEventListener === 'function' &&
     typeof self.window === 'undefined') {
-    self.addEventListener('message', (event) => {
-        const data = event.data;
-        if (!data || typeof data !== 'object')
-            return;
-        if (data.type === 'init') {
-            const init = data;
-            // The synchronous host-call bridge (SharedArrayBuffer + Atomics) is set
-            // up here from init.fuelPerDispatch/watchdogMs; instantiation uses
-            // buildImportObject so the guest sees only ck.* host functions.
-            void parseFuelBudget(init.fuelPerDispatch);
-            void (init.watchdogMs ?? 250);
-            self.postMessage?.({ type: 'ready' });
-            return;
-        }
+    startGlueWorker({
+        addEventListener: self.addEventListener.bind(self),
+        postMessage: (m) => self.postMessage?.(m),
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdedkingdoms/crowdyjs",
-  "version": "8.17.0",
+  "version": "8.19.0",
   "description": "Client SDK for Crowded Kingdoms GraphQL API with UDP proxy support",
   "type": "module",
   "main": "dist/index.js",
@@ -70,11 +70,18 @@
     "@graphql-tools/merge": "^9.1.10",
     "@types/node": "^22.10.7",
     "typescript": "^5.7.3",
-    "ws": "^8.20.0"
+    "ws": "^8.21.1"
   },
   "dependencies": {
+    "@codingame/monaco-vscode-editor-api": "25.1.2",
     "@graphql-typed-document-node/core": "^3.2.0",
+    "dompurify": "3.4.12",
     "graphql": "^16.13.2",
-    "graphql-ws": "^6.0.8"
+    "graphql-ws": "^6.0.8",
+    "monaco-languageclient": "10.7.0",
+    "vscode-ws-jsonrpc": "3.5.0"
+  },
+  "overrides": {
+    "dompurify": "$dompurify"
   }
 }