@pie-project/server-web 0.5.2 → 0.6.1

package/dist/worker.mjs

@@ -81,20 +81,24 @@ function pie_init(log_filter) {
   var len0 = WASM_VECTOR_LEN;
   wasm2.pie_init(ptr0, len0);
 }
-function pie_install_language(language, component) {
+function pie_install_language(language, component, precompiled) {
   const ptr0 = passStringToWasm0(language, wasm2.__wbindgen_export, wasm2.__wbindgen_export2);
   const len0 = WASM_VECTOR_LEN;
   const ptr1 = passArray8ToWasm0(component, wasm2.__wbindgen_export);
   const len1 = WASM_VECTOR_LEN;
-  const ret = wasm2.pie_install_language(ptr0, len0, ptr1, len1);
+  var ptr2 = isLikeNone(precompiled) ? 0 : passArray8ToWasm0(precompiled, wasm2.__wbindgen_export);
+  var len2 = WASM_VECTOR_LEN;
+  const ret = wasm2.pie_install_language(ptr0, len0, ptr1, len1, ptr2, len2);
   return takeObject(ret);
 }
-function pie_install_program(component, manifest_toml) {
-  const ptr0 = passArray8ToWasm0(component, wasm2.__wbindgen_export);
+function pie_install_program(bytes, file, version) {
+  const ptr0 = passArray8ToWasm0(bytes, wasm2.__wbindgen_export);
   const len0 = WASM_VECTOR_LEN;
-  const ptr1 = passStringToWasm0(manifest_toml, wasm2.__wbindgen_export, wasm2.__wbindgen_export2);
+  const ptr1 = passStringToWasm0(file, wasm2.__wbindgen_export, wasm2.__wbindgen_export2);
   const len1 = WASM_VECTOR_LEN;
-  const ret = wasm2.pie_install_program(ptr0, len0, ptr1, len1);
+  var ptr2 = isLikeNone(version) ? 0 : passStringToWasm0(version, wasm2.__wbindgen_export, wasm2.__wbindgen_export2);
+  var len2 = WASM_VECTOR_LEN;
+  const ret = wasm2.pie_install_program(ptr0, len0, ptr1, len1, ptr2, len2);
   return takeObject(ret);
 }
 function pie_open_session() {
@@ -297,7 +301,7 @@ function __wbg_get_imports() {
       const ret = getObject(arg0).features;
       return addHeapObject(ret);
     },
-    __wbg_fetchRange_59f4c213313c928d: function(arg0, arg1, arg2) {
+    __wbg_fetchRange_837bbd1b92ceed92: function(arg0, arg1, arg2) {
       __pieHost.fetchRange(arg0, arg1, arg2 >>> 0);
     },
     __wbg_finish_09ec094c10f41e7b: function(arg0) {
@@ -557,7 +561,7 @@ function __wbg_get_imports() {
           const a = state0.a;
           state0.a = 0;
           try {
-            return __wasm_bindgen_func_elem_12287(a, state0.b, arg02, arg12);
+            return __wasm_bindgen_func_elem_55690(a, state0.b, arg02, arg12);
           } finally {
             state0.a = a;
           }
@@ -898,23 +902,23 @@ function __wbg_get_imports() {
       }, arguments);
     },
     __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_12285);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_55688);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_10965);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_11414);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_10966);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_11415);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_10965_14);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_11414_15);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000005: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_10965_15);
+      const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_11414_16);
       return addHeapObject(ret);
     },
     __wbindgen_generic_0000000000000006: function(arg0) {
@@ -946,16 +950,16 @@ function __wbg_get_imports() {
     "./platform.mjs": platform_exports
   };
 }
-function __wasm_bindgen_func_elem_10966(arg0, arg1, arg2) {
-  wasm2.__wasm_bindgen_func_elem_10966(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_11415(arg0, arg1, arg2) {
+  wasm2.__wasm_bindgen_func_elem_11415(arg0, arg1, addHeapObject(arg2));
 }
-function __wasm_bindgen_func_elem_12287(arg0, arg1, arg2, arg3) {
-  wasm2.__wasm_bindgen_func_elem_12287(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_55690(arg0, arg1, arg2, arg3) {
+  wasm2.__wasm_bindgen_func_elem_55690(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
-function __wasm_bindgen_func_elem_12285(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_55688(arg0, arg1, arg2) {
   try {
     const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-    wasm2.__wasm_bindgen_func_elem_12285(retptr, arg0, arg1, addHeapObject(arg2));
+    wasm2.__wasm_bindgen_func_elem_55688(retptr, arg0, arg1, addHeapObject(arg2));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     if (r1) {
@@ -965,10 +969,10 @@ function __wasm_bindgen_func_elem_12285(arg0, arg1, arg2) {
     wasm2.__wbindgen_add_to_stack_pointer(16);
   }
 }
-function __wasm_bindgen_func_elem_10965(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_11414(arg0, arg1, arg2) {
   try {
     const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-    wasm2.__wasm_bindgen_func_elem_10965(retptr, arg0, arg1, addHeapObject(arg2));
+    wasm2.__wasm_bindgen_func_elem_11414(retptr, arg0, arg1, addHeapObject(arg2));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     if (r1) {
@@ -978,10 +982,10 @@ function __wasm_bindgen_func_elem_10965(arg0, arg1, arg2) {
     wasm2.__wbindgen_add_to_stack_pointer(16);
   }
 }
-function __wasm_bindgen_func_elem_10965_14(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_11414_15(arg0, arg1, arg2) {
   try {
     const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-    wasm2.__wasm_bindgen_func_elem_10965_14(retptr, arg0, arg1, addHeapObject(arg2));
+    wasm2.__wasm_bindgen_func_elem_11414_15(retptr, arg0, arg1, addHeapObject(arg2));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     if (r1) {
@@ -991,10 +995,10 @@ function __wasm_bindgen_func_elem_10965_14(arg0, arg1, arg2) {
     wasm2.__wbindgen_add_to_stack_pointer(16);
   }
 }
-function __wasm_bindgen_func_elem_10965_15(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_11414_16(arg0, arg1, arg2) {
   try {
     const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-    wasm2.__wasm_bindgen_func_elem_10965_15(retptr, arg0, arg1, addHeapObject(arg2));
+    wasm2.__wasm_bindgen_func_elem_11414_16(retptr, arg0, arg1, addHeapObject(arg2));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     if (r1) {
@@ -1477,11 +1481,11 @@ var host = {
   async awaitCache() {
     await cacheFill;
   },
-  async installLanguage(language, wasmBytes) {
-    return await driven(pie_install_language(language, wasmBytes));
+  async installLanguage(language, wasmBytes, precompiled) {
+    return await driven(pie_install_language(language, wasmBytes, precompiled));
   },
-  async install(wasmBytes, manifestToml) {
-    return await driven(pie_install_program(wasmBytes, manifestToml));
+  async install(bytes, file, version) {
+    return await driven(pie_install_program(bytes, file, version ?? void 0));
   },
   async memoryBytes() {
     return wasm3.memory.buffer.byteLength;

package/index.d.ts

@@ -1,6 +1,6 @@
-import { PieClient } from "@pie-project/client";
+import { PieClient, programFile } from "@pie-project/client";
 
-export { PieClient };
+export { PieClient, programFile };
 
 export interface LoadInfo {
   worker: boolean;
@@ -15,7 +15,7 @@ export interface LoadOptions {
 
 export interface BootSummary {
   model: string;
-  sku: string;
+  deployment: string;
   trace: string;
   weight_bytes: number;
   kv_pages: number;
@@ -32,7 +32,7 @@ export function bootLazy(
 
 export function awaitCache(): Promise<void>;
 
-export function install(wasmBytes: Uint8Array | ArrayBuffer, manifestToml: string): Promise<string>;
+export function install(bytes: Uint8Array | ArrayBuffer, file: string, version?: string | null): Promise<string>;
 
 export function client(): PieClient;
 
@@ -56,8 +56,15 @@ export class Server {
   readonly summary: BootSummary;
   readonly url: string;
   readonly running: boolean;
-  installLanguage(language: "python" | "javascript" | string, source: Uint8Array | ArrayBuffer | URL | string): Promise<string>;
-  install(source: Uint8Array | ArrayBuffer | URL | string, manifest: string): Promise<string>;
+  /** `precompiled` is the same component from `precompileComponent` (the
+   * `precompile` entry point) on this same build; it spares the first
+   * script inferlet compiling the component, which takes seconds in a tab. */
+  installLanguage(
+    language: "python" | "javascript" | string,
+    source: Uint8Array | ArrayBuffer | URL | string,
+    options?: { precompiled?: Uint8Array | ArrayBuffer | URL | string },
+  ): Promise<string>;
+  install(source: Uint8Array | ArrayBuffer | URL | string, file?: string | null, version?: string | null): Promise<string>;
   connect(): Promise<PieClient>;
   memoryBytes(): Promise<number>;
   awaitCache(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pie-project/server-web",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "The browser half of @pie-project/server: the runtime and the WebGPU engine as wasm, reached through `import { Server } from \"@pie-project/server\"` under a bundler.",
   "type": "module",
   "main": "dist/pie.mjs",
@@ -13,7 +13,8 @@
     "./languages": {
       "types": "./src/languages.d.ts",
       "default": "./src/languages.mjs"
-    }
+    },
+    "./precompile": "./dist/precompile.mjs"
   },
   "files": [
     "dist",
@@ -22,10 +23,10 @@
   ],
   "scripts": {
     "build": "./build.sh release",
-    "bundle": "esbuild src/pie.mjs src/worker.mjs --bundle --format=esm --outdir=dist --out-extension:.js=.mjs --external:./worker.mjs --external:fs --define:__PIE_WASM__='\"./pie_browser_bg.wasm\"' --log-level=warning --log-override:duplicate-object-key=silent && cp pkg/pie_browser_bg.wasm dist/"
+    "bundle": "esbuild src/pie.mjs src/worker.mjs src/precompile.mjs --bundle --format=esm --outdir=dist --out-extension:.js=.mjs --external:./worker.mjs --external:fs --external:path --external:node:fs --external:node:url --define:__PIE_WASM__='\"./pie_browser_bg.wasm\"' --log-level=warning --log-override:duplicate-object-key=silent && cp pkg/pie_browser_bg.wasm dist/"
   },
   "dependencies": {
-    "@pie-project/client": "^0.5.0"
+    "@pie-project/client": "^0.6.0"
   },
   "devDependencies": {
     "esbuild": "^0.28.2"
@@ -33,6 +34,6 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/pie-project/pie",
-    "directory": "javascript/server-web"
+    "directory": "packages/javascript/server-web"
   }
 }

package/src/pie.mjs

@@ -1,9 +1,9 @@
-import { PieClient } from "@pie-project/client";
+import { PieClient, programFile } from "@pie-project/client";
 
 import { socketClass } from "./transport.mjs";
 import { attachLanguages } from "./languages.mjs";
 
-export { PieClient };
+export { PieClient, programFile };
 
 const WASM_PATH = typeof __PIE_WASM__ === "undefined" ? "../pkg/pie_browser_bg.wasm" : __PIE_WASM__;
 
@@ -93,16 +93,22 @@ export async function connect() {
   return c;
 }
 
-export async function install(wasmBytes, manifestToml) {
-  const copy = new Uint8Array(wasmBytes).slice();
-  return await ready().call("install", [copy, manifestToml], { transfer: [copy.buffer] });
+export async function install(bytes, file, version = null) {
+  const copy = new Uint8Array(bytes).slice();
+  return await ready().call("install", [copy, file, version], { transfer: [copy.buffer] });
 }
 
 /** Hand the runtime a language component (`"python"`, `"javascript"`)
- * from bytes; a script inferlet in that language can run once this has. */
-export async function installLanguage(language, wasmBytes) {
+ * from bytes; a script inferlet in that language can run once this has.
+ * `precompiled`, from `precompileComponent` on this same build, spares the
+ * first such inferlet compiling the component; one the runtime refuses is
+ * ignored and the source compiled instead. */
+export async function installLanguage(language, wasmBytes, precompiled) {
   const copy = new Uint8Array(wasmBytes).slice();
-  return await ready().call("installLanguage", [language, copy], { transfer: [copy.buffer] });
+  const ready_ = precompiled ? new Uint8Array(precompiled).slice() : undefined;
+  return await ready().call("installLanguage", [language, copy, ready_], {
+    transfer: ready_ ? [copy.buffer, ready_.buffer] : [copy.buffer],
+  });
 }
 
 export async function memoryBytes() {
@@ -117,9 +123,12 @@ export async function awaitCache() {
   return await ready().call("awaitCache", []);
 }
 
+function isBytes(source) {
+  return source instanceof Uint8Array || source instanceof ArrayBuffer;
+}
+
 async function bytesOf(source) {
-  if (source instanceof Uint8Array) return source;
-  if (source instanceof ArrayBuffer) return new Uint8Array(source);
+  if (isBytes(source)) return new Uint8Array(source);
   const response = await fetch(source);
   if (!response.ok) throw new Error(`pie: ${source}: ${response.status} ${response.statusText}`);
   return new Uint8Array(await response.arrayBuffer());
@@ -150,7 +159,7 @@ export class Server {
     return server;
   }
 
-  /** What the boot found: model, sku, weight bytes, kv pages. */
+  /** What the boot found: model, deployment, weight bytes, kv pages. */
   get summary() {
     return this.#summary;
   }
@@ -165,16 +174,25 @@ export class Server {
     return this.#open && backend !== null;
   }
 
-  /** A language component (`python`, `javascript`) from bytes or a URL. */
-  async installLanguage(language, source) {
+  /** A language component (`python`, `javascript`) from bytes or a URL,
+   * and optionally the same component precompiled for this build. A
+   * precompiled one that fails to fetch is skipped, not fatal. */
+  async installLanguage(language, source, { precompiled } = {}) {
     this.#alive();
-    return installLanguage(language, await bytesOf(source));
+    const [bytes, ready_] = await Promise.all([
+      bytesOf(source),
+      precompiled ? bytesOf(precompiled).catch(() => undefined) : undefined,
+    ]);
+    return installLanguage(language, bytes, ready_);
   }
 
-  /** An inferlet from its component bytes (or URL) and manifest text, replacing an installed version. */
-  async install(source, manifest) {
+  async install(source, file = null, version = null) {
     this.#alive();
-    return install(await bytesOf(source), manifest);
+    if (!file) {
+      if (isBytes(source)) throw new Error("Server.install: bytes need `file`, the program's file name (`x.wasm`, `x.py`, `x.js`)");
+      file = programFile(new URL(source, location.href));
+    }
+    return install(await bytesOf(source), file, version);
   }
 
   /** A `PieClient` connected in-page. */

package/src/precompile.mjs

@@ -0,0 +1,37 @@
+// Precompile a language component for the engine a tab runs inferlets on.
+// A tab compiles the Python language component (37 MB) on its first Python
+// inferlet, which takes seconds; a site can run this once at build time and
+// serve the result beside the source, for `Server.installLanguage(language,
+// source, { precompiled })`. The result fits only this exact build of
+// pie_browser_bg.wasm, so run the copy that ships with the page.
+//
+//   node precompile.mjs python.wasm python.pulley.cwasm
+//
+// Needs no GPU: it builds the inferlet engine, not a server.
+import { readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { initSync, pie_precompile_component } from "../pkg/pie_browser.js";
+
+let ready = false;
+
+/** The component's bytes, precompiled for this build's engine. */
+export function precompileComponent(component) {
+  if (!ready) {
+    initSync({ module: readFileSync(new URL(__PIE_WASM__, import.meta.url)) });
+    ready = true;
+  }
+  return pie_precompile_component(new Uint8Array(component));
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const [source, out] = process.argv.slice(2);
+  if (!source || !out) {
+    console.error("usage: node precompile.mjs <component.wasm> <out.cwasm>");
+    process.exit(2);
+  }
+  const started = performance.now();
+  const precompiled = precompileComponent(readFileSync(source));
+  writeFileSync(out, precompiled);
+  const seconds = ((performance.now() - started) / 1000).toFixed(1);
+  console.log(`${out}: ${(precompiled.length / 1048576).toFixed(1)} MiB in ${seconds} s`);
+}

package/src/worker.mjs

@@ -180,11 +180,11 @@ export const host = {
     await cacheFill;
   },
 
-  async installLanguage(language, wasmBytes) {
-    return await driven(bindings.pie_install_language(language, wasmBytes));
+  async installLanguage(language, wasmBytes, precompiled) {
+    return await driven(bindings.pie_install_language(language, wasmBytes, precompiled));
   },
-  async install(wasmBytes, manifestToml) {
-    return await driven(bindings.pie_install_program(wasmBytes, manifestToml));
+  async install(bytes, file, version) {
+    return await driven(bindings.pie_install_program(bytes, file, version ?? undefined));
   },
 
   async memoryBytes() {

package/README.md

@@ -1,91 +0,0 @@
-# @pie-project/server-web
-
-The browser half of `@pie-project/server`: the same runtime, WebGPU engine
-and inferlet sandbox as `pie serve`, compiled to `wasm32-unknown-unknown`.
-No server-side inference: the page fetches a `.wgpu.zt` artifact, the
-weights land in WebGPU buffers, and inferlets run under wasmtime's Pulley
-interpreter inside the same module. A bundler reaches it through
-`@pie-project/server`'s `browser` export condition; nothing imports it by
-name.
-
-## Use
-
-The package ships the wasm and a self-contained bundle (`dist/pie.mjs`,
-`dist/worker.mjs`, `dist/pie_browser_bg.wasm`); the client
-(`@pie-project/client`) is bundled in and re-exported. The worker and the
-wasm are fetched relative to the module, so serve them from your own origin
-(a bundler that understands `new URL(…, import.meta.url)` — Vite, webpack 5 —
-does this by itself; without one, copy `dist/` next to your page).
-
-```js
-import { Server } from "@pie-project/server";      // resolves here under a bundler
-import "@pie-project/language-python";
-
-const server = await Server.start({ model: "/models/qwen3.5-0.8b.wgpu.zt" });   // served with Range support
-const program = await server.install(inferletBytes, manifestToml);
-const client = await server.connect();              // a PieClient, as for `pie serve`
-const proc = await client.launchProcess(program, { prompt: "The capital of France is", max_tokens: 16 });
-for (;;) {
-  const { event, value } = await proc.recv();
-  if (event === "return" || event === "error") break;
-}
-await server.shutdown();
-```
-
-The page-level functions behind the class (`load`, `bootLazy`, `install`,
-`installLanguage`, `connect`, `awaitCache`, `memoryBytes`) are exported as
-well; `tests/browser` drives them directly.
-
-
-- The page must be cross-origin isolated (`Cross-Origin-Opener-Policy:
-  same-origin`, `Cross-Origin-Embedder-Policy: require-corp`), and the
-  browser needs WebGPU and JSPI: Chrome 137+, Firefox 153+ (Firefox on
-  Linux has no WebGPU, so the engine cannot boot there).
-- `bootLazy` never holds the artifact in the tab: the loader's reads are
-  served as 8 MiB-aligned `Range` requests, and after a boot from the
-  network the artifact is copied into the origin's private file system
-  (files up to about 2 GB) so the next visit reads it from there;
-  `awaitCache()` waits for that copy. Peak wasm memory is a few times the
-  largest tensor: 0.8B boots in 285 MiB, 9B in 4 bits in 1.5 GiB.
-- The engine cannot ask WebGPU how much device memory there is and assumes
-  8 GiB; a large model with the default pools is refused ("raise the device
-  weight budget") — pass `device_memory_mb = 20480` (or a smaller
-  `max_total_pages`) in the boot config. `BootConfig` in
-  `crates/browser/src/boot.rs` lists the keys.
-- Rust, JavaScript and Python inferlets run. Not available in a tab: MoE
-  host-tier expert streaming, Python inferlet snapshots, telemetry, and
-  outbound HTTP or files from inferlets (the WASI interfaces link, a call
-  fails).
-- `index.d.ts` carries the types.
-
-## Build
-
-```bash
-rustup target add wasm32-unknown-unknown
-cargo install wasm-bindgen-cli --version 0.2.128 --locked   # must match Cargo.lock
-./javascript/server-web/build.sh          # release; `min` for the 23 MB shipping build, `dev` for debug
-```
-
-`build.sh` builds `crates/browser`, runs wasm-bindgen into `pkg/`, and bundles
-`src/` with esbuild into `dist/` (`npm run bundle`). The package's own
-dependencies are installed on the first run. Tests, benchmarks and CI gates
-live under `tests/browser` (see its README).
-
-## How it fits together
-
-| piece | what it does |
-|---|---|
-| `crates/browser` | The wasm-bindgen host: boot, install, sessions speaking the MessagePack frames `pie serve`'s WebSocket carries, `pie_tick`. |
-| `crates/wasmtime-web` | wasmtime in a tab: heap-backed "virtual memory", TLS slots, fibers implemented by the page's JSPI glue (`src/platform.mjs`), and the WASI host for the inferlet's imports (cli, io, clocks, random; 0.2 linked by hand, the 0.3 clocks from `crates/inferlet/wit`). The 0.2 filesystem and http interfaces a JavaScript or Python guest runtime imports regardless are stubbed per component, so they link and only a call fails. |
-| `crates/web-std` | The executor the page ticks, timers over `performance.now()`, crossbeam-shaped channels, and green threads on fibers. The runtime's scheduler and engine lanes run on those unchanged; `crates/runtime`'s `rt` facade names it on wasm32. |
-| `crates/engine-wgpu` | The same engine on both hosts, written for the browser: no GPU wait blocks, every step lands by callback, guests run from the landing. What differs by host sits in `device/host.rs`. |
-| `src/worker.mjs` | The host: wasm init, the tick loop, sessions, the artifact served by byte range. Runs in a Web Worker so the page stays responsive through the inferlet's in-browser compile and every forward pass; `load({ worker: false })` runs it on the page for debugging. |
-| `src/pie.mjs` | The page-side API: the `Server` class over `load`, `bootLazy`, `install`, `connect`. |
-| `src/languages.mjs` | The language registry `@pie-project/server/languages` re-exports: what a language package calls on import. |
-| `src/platform.mjs` | Fibers (JSPI), the clock, the wake hook the wasm imports. |
-| `src/transport.mjs` | The client's in-page socket over the runtime's frame API. |
-
-The native wgpu server is the engine's test host rather than a production
-backend: it runs the browser's code path over Vulkan, Metal or DX12 with a
-poll thread standing in for the page's event loop, so what the browser suite
-exercises is exercised natively too, and the two produce identical tokens.