@pie-project/server-web 0.5.2 → 0.6.0

package/README.md

@@ -22,7 +22,7 @@ import { Server } from "@pie-project/server";      // resolves here under a bund
 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 program = await server.install("/inferlets/beam_search.wasm");   // a URL, or bytes with a file name
 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 (;;) {
@@ -50,8 +50,19 @@ well; `tests/browser` drives them directly.
 - 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.
+  `device_kv_budget`) in the boot config. `Settings` in
+  `crates/worker/src/embedded.rs` lists the keys, plus `device_memory_mb` and
+  `power_preference` for the WebGPU engine.
+- A tab compiles a script language's component (Python's is 37 MB) on the
+  first inferlet in that language, about 8 s, and again after every reload.
+  Precompile it once at build time with this same build,
+  `node node_modules/@pie-project/server-web/dist/precompile.mjs python.wasm
+  python.pulley.cwasm` (or `precompileComponent` from
+  `@pie-project/server-web/precompile`; no GPU needed), serve the result
+  beside the source, and pass it as
+  `installLanguage("python", source, { precompiled })`. It fits only the
+  `pie_browser_bg.wasm` it was made with; one that does not is ignored with
+  a warning and the source compiled instead.
 - 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
@@ -63,10 +74,10 @@ well; `tests/browser` drives them directly.
 ```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
+./packages/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
+`build.sh` builds the crate in `rust/`, 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).
@@ -75,7 +86,7 @@ live under `tests/browser` (see its README).
 
 | piece | what it does |
 |---|---|
-| `crates/browser` | The wasm-bindgen host: boot, install, sessions speaking the MessagePack frames `pie serve`'s WebSocket carries, `pie_tick`. |
+| `rust/` (crate `pie-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`. |

package/dist/pie.mjs

@@ -2502,6 +2502,19 @@ var CHUNK_SIZE = 256 * 1024;
 function hashBytes(bytes) {
   return bytesToHex(blake3(bytes));
 }
+var PROGRAM_EXTENSION = { wasm: "wasm", py: "py", js: "js", mjs: "js" };
+function programFile(path) {
+  const text = path instanceof URL ? decodeURIComponent(path.pathname) : String(path);
+  const parts = text.replace(/\\/g, "/").replace(/\/+$/, "").split("/");
+  const base = parts.pop();
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) throw new Error(`${text} has no extension; a program is a .wasm, .py or .js file`);
+  const extension = PROGRAM_EXTENSION[base.slice(dot + 1)];
+  if (!extension) throw new Error(`${text} is not a program pie can install; a program is a .wasm component or a .py / .js script`);
+  const stem = base.slice(0, dot);
+  const name = extension !== "wasm" && (stem === "main" || stem === "index") ? parts.pop() || stem : stem;
+  return `${name.replace(/_/g, "-")}.${extension}`;
+}
 var Bytes = globalThis.Buffer ?? Uint8Array;
 function concatBytes(chunks) {
   if (globalThis.Buffer) return Buffer.concat(chunks);
@@ -2546,19 +2559,15 @@ var ReceivedFile = class _ReceivedFile extends Bytes {
   }
 };
 var Inferlet = class {
-  constructor({ fn, name, version, entry, source, description }) {
-    Object.assign(this, { fn, name, version, entry, source, description });
+  constructor({ fn, name, version, source }) {
+    Object.assign(this, { fn, name, version, source });
   }
   /** `name@version`, the id the server launches by. */
   get program() {
     return `${this.name}@${this.version}`;
   }
-  manifestToml() {
-    const q = (s) => JSON.stringify(String(s));
-    const lines = ["[package]", `name = ${q(this.name)}`, `version = ${q(this.version)}`];
-    if (this.description) lines.push(`description = ${q(this.description)}`);
-    lines.push("", "[runtime]", 'language = "javascript"', `entry = ${q(this.entry)}`);
-    return lines.join("\n") + "\n";
+  get file() {
+    return `${this.name}.js`;
   }
 };
 var Process = class {
@@ -2867,25 +2876,16 @@ var PieClient = class {
   // =========================================================================
   // Program Upload
   // =========================================================================
-  /**
-   * Installs a program to the server in chunks.
-   * @param {string} wasmPath Path to the WASM binary file (Node.js only).
-   * @param {string} manifestPath Path to the manifest TOML file (Node.js only).
-   */
-  async installProgram(wasmPath, manifestPath, forceOverwrite = false) {
+  async installProgram(path, version = null, forceOverwrite = false) {
     const fs = await import("fs");
-    const programBytes = fs.readFileSync(wasmPath);
-    const manifest = fs.readFileSync(manifestPath, "utf-8");
-    return await this.installProgramBytes(programBytes, manifest, forceOverwrite);
+    const { resolve } = await import("path");
+    const programBytes = fs.readFileSync(path);
+    return await this.installProgramBytes(programBytes, programFile(resolve(path)), version, forceOverwrite);
   }
   /**
-   * Installs a program from its artifact bytes (a component, or a script's
-   * source when the manifest names a `[runtime] language`) and its
-   * manifest TOML.
    * @param {Uint8Array} programBytes
-   * @param {string} manifest
    */
-  async installProgramBytes(programBytes, manifest, forceOverwrite = false) {
+  async installProgramBytes(programBytes, file, version = null, forceOverwrite = false) {
     if (typeof Buffer !== "undefined" && !Buffer.isBuffer(programBytes)) {
       programBytes = Buffer.from(programBytes.buffer, programBytes.byteOffset, programBytes.byteLength);
     }
@@ -2902,7 +2902,8 @@ var PieClient = class {
         type: "add_program",
         corr_id,
         program_hash: programHash,
-        manifest,
+        file,
+        version,
         force_overwrite: forceOverwrite,
         chunk_index: i,
         total_chunks: totalChunks,
@@ -2914,6 +2915,7 @@ var PieClient = class {
     if (!ok) {
       throw new Error(`Program install failed: ${result}`);
     }
+    return result;
   }
   // =========================================================================
   // File Transfer (fire-and-forget)
@@ -2944,14 +2946,16 @@ var PieClient = class {
    * @param {string} inferlet The inferlet name (e.g., "text-completion@0.1.0").
    * @param {Object} [input={}] Input parameters object, serialized to JSON.
    * @param {boolean} [captureOutputs=true] Stream outputs to client.
+   * @param {Object<string, Uint8Array>} [files={}] Files the inferlet reads with `session.file(name)`.
    * @returns {Promise<Process>}
    */
-  async launchProcess(inferlet, input = {}, captureOutputs = true) {
+  async launchProcess(inferlet, input = {}, captureOutputs = true, files = {}) {
     const msg = {
       type: "launch_process",
       inferlet,
       input: JSON.stringify(input),
-      capture_outputs: captureOutputs
+      capture_outputs: captureOutputs,
+      files
     };
     const { ok, result } = await this._sendMsgAndWait(msg);
     if (!ok) {
@@ -2983,7 +2987,8 @@ var PieClient = class {
       if (!await this.checkProgram(program.program)) {
         await this.installProgramBytes(
           new TextEncoder().encode(program.source),
-          program.manifestToml()
+          program.file,
+          program.version
         );
       }
       program = program.program;
@@ -3219,13 +3224,16 @@ async function connect() {
   await c.connect();
   return c;
 }
-async function install(wasmBytes, manifestToml) {
-  const copy = new Uint8Array(wasmBytes).slice();
-  return await ready().call("install", [copy, manifestToml], { transfer: [copy.buffer] });
+async function install(bytes, file, version = null) {
+  const copy = new Uint8Array(bytes).slice();
+  return await ready().call("install", [copy, file, version], { transfer: [copy.buffer] });
 }
-async function installLanguage(language, wasmBytes) {
+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() : void 0;
+  return await ready().call("installLanguage", [language, copy, ready_], {
+    transfer: ready_ ? [copy.buffer, ready_.buffer] : [copy.buffer]
+  });
 }
 async function memoryBytes() {
   return await ready().call("memoryBytes");
@@ -3236,9 +3244,11 @@ async function bootLazy(url, config, onProgress) {
 async function awaitCache() {
   return await ready().call("awaitCache", []);
 }
+function isBytes2(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 (isBytes2(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());
@@ -3264,7 +3274,7 @@ var Server = class _Server {
     server.#detach = await attachLanguages(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;
   }
@@ -3276,15 +3286,24 @@ var Server = class _Server {
   get running() {
     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(() => void 0) : void 0
+    ]);
+    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 (isBytes2(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. */
   async connect() {
@@ -3324,7 +3343,8 @@ export {
   install,
   installLanguage,
   load,
-  memoryBytes
+  memoryBytes,
+  programFile
 };
 /*! Bundled license information: