@remix_labs/machine-starter 2.3465.0-dev → 2.11723.0-dev

package/mixcore.lib.mjs

@@ -0,0 +1,647 @@
+
+;// ./src/mixcore-wasm-api.js
+let MIXCORE_TRACE = false;
+
+// JS interface to the Mixcore C-API implemented in
+// `mix-rs:mixcore/src/c_api.rs`.
+class MixcoreWasmApi {
+  // log: e.g. `info,mixcore=debug`
+  static async create(wasm, wasi, log) {
+    let wasmApi = new MixcoreWasmApi();
+    let imports = {
+      wasi_snapshot_preview1: wasi.wasiImport,
+      env: {
+        mixcore_http_request: wasmApi.httpRequest.bind(wasmApi),
+        mixcore_http_drop_response: wasmApi.httpDropResponse.bind(wasmApi),
+        mixcore_file_url: wasmApi.fileUrl.bind(wasmApi),
+      },
+    };
+    let instance = await WebAssembly.instantiate(wasm, imports);
+    if (instance.instance !== undefined) {
+      // does instantiate return an instance or {instance, module}
+      // depending on whether the module is a bytebuffer or a Wasm module?
+      instance = instance.instance;
+    }
+    wasi.inst = instance;
+    wasmApi.instance = instance;
+    wasmApi.mem = instance.exports.memory;
+    wasmApi.api = instance.exports; // Mixcore C-API
+    wasmApi.urls = {};
+    // get preopened wasi directory, only using bjorn's WASI shim
+    wasmApi.fs = wasi.fds ? wasi.fds[3] : null;
+    if (log) wasmApi.mixcoreInitLogging(log);
+    return wasmApi;
+  }
+
+  mixcoreInitLogging(log) {
+    if (log) {
+      this.callAPI("mixcore_init_logging", [log]);
+    }
+  }
+  mixcoreSetup(dbDir, dbName, user) {
+    let { result: ptr } = this.callAPI("mixcore_setup", [
+      dbDir,
+      dbName,
+      user,
+      JSON.stringify({ user }),
+      null,
+      null,
+      { kind: "error" },
+    ]);
+    return ptr;
+  }
+  initRemixFile(remixPath, dbPath, user) {
+    let { result: manifestJson } = this.callAPI(
+      "mixcore_init_remix_file",
+      [remixPath, dbPath, user, { kind: "error" }],
+      { result: { type: "string" } },
+    );
+    return JSON.parse(manifestJson);
+  }
+  initRemixFileBuffer(remixBuf, dbPath, user) {
+    let { result: manifestJson } = this.callAPI(
+      "mixcore_init_remix_file_buffer",
+      [remixBuf, remixBuf.byteLength, dbPath, user, { kind: "error" }],
+      { result: { type: "string" } },
+    );
+    return JSON.parse(manifestJson);
+  }
+  ffiNames(mixcorePtr) {
+    if (mixcorePtr === undefined)
+      throw new Error("mixcore-wasm-api: ffiNames requires mixcorePtr");
+    let {
+      out: { namesPtr, len },
+    } = this.callAPI("mixcore_ffi_names", [
+      mixcorePtr,
+      { kind: "error" },
+      { kind: "out", type: "word", name: "namesPtr" },
+      { kind: "out", type: "word", name: "len" },
+    ]);
+    let names = [];
+    for (let i = 0; i < len; i++) {
+      let ptr = this.readUint32(namesPtr + 4 * i);
+      let name = this.readString(ptr);
+      names.push(name);
+    }
+    this.callAPI("mixcore_ffi_names_drop", [namesPtr, len]);
+    return names;
+  }
+  async ffiDispatch(mixcorePtr, co, name, argsBuf) {
+    let { out } = this.callAPI("mixcore_ffi_dispatch", [
+      mixcorePtr,
+      co,
+      name,
+      argsBuf,
+      argsBuf.byteLength,
+      true,
+      { kind: "out", type: "bool", name: "ffiFound" },
+      { kind: "out", type: "bool", name: "isAsync" },
+      { kind: "out", type: "word", name: "resBufPtr" },
+      { kind: "out", type: "word", name: "resLen" },
+      { kind: "out", type: "string", name: "ffiErr" },
+      { kind: "out", type: "string", name: "mixErr" },
+      { kind: "out", type: "string", name: "mixBacktrace" },
+      { kind: "out", type: "string", name: "rawBacktrace" },
+    ]);
+    this.assert(out.ffiFound, "registered FFI found");
+    this.assert(!out.isAsync, "forced sync FFI dispatch");
+    if (out.ffiErr != null) {
+      throw new Error(`FFI ${name}: ${out.ffiErr}`);
+    }
+    if (out.mixErr != null) {
+      console.error("Mix error:", out.mixErr);
+      console.error(out.rawBacktrace);
+      console.error(out.mixBacktrace);
+      throw new Error(`Mix error: ${out.mixErr}`);
+    }
+    return this.readDropBuffer(out.resBufPtr, out.resLen);
+  }
+  mixcoreGetCodes(dbDir, dbName, standaloneName) {
+    let {
+      out: { codesPtr, count },
+    } = this.callAPI("mixcore_get_codes", [
+      dbDir,
+      dbName,
+      standaloneName,
+      false,
+      { kind: "error" },
+      { kind: "out", type: "word", name: "codesPtr" },
+      { kind: "out", type: "word", name: "count" },
+    ]);
+    let codes = [];
+    for (let i = 0; i < count; i++) {
+      let codePtr = codesPtr + i * 16;
+      let idPtr = this.readUint32(codePtr);
+      let bufPtr = this.readUint32(codePtr + 4);
+      let bufLen = this.readUint32(codePtr + 8);
+      let ondemandAppsPtr = this.readUint32(codePtr + 12);
+      let codeId = this.readString(idPtr);
+      let codeBuf = this.readUint8Buffer(bufPtr, bufLen);
+      let ondemandAppsStr = this.readString(ondemandAppsPtr);
+      let ondemandApps = ondemandAppsStr ? ondemandAppsStr.split(",") : [];
+      codes.push({ codeId, codeBuf, ondemandApps });
+    }
+    this.callAPI("mixcore_codes_drop", [codesPtr, count]);
+    return codes;
+  }
+  registerDebugObject(codeId, buf) {
+    this.callAPI("mixcore_register_debug_object", [
+      codeId,
+      buf,
+      buf.byteLength,
+      { kind: "error" },
+    ]);
+  }
+
+  /** `callAPI(fname, [arg1, ...], options)` calls the Wasm function called
+   * `fname`. The Wasm function may have input parameters and output parameters
+   * (as a pointer) and return a value. Input arguments `arg1`, ... are plain
+   * values of the following types:
+   *
+   * JS value    | Wasm value
+   * ------------|-----------------
+   * null        | 0
+   * 0xbeef      | 0xbeef
+   * true/false  | 1/0
+   * "string"    | C-string pointer
+   * ArrayBuffer | u8 pointer
+   *
+   * Output parameters must be objects of the shape `{kind: "out", type: TYPE,
+   * name: NAME}`. The type may be `"string"`, `"word"`, or `"bool"`, and the
+   * name is a string.
+   *
+   * The result of the call is an object `{ result, out }` where `result` is the
+   * result of the Wasm call, and out is an object that maps the names of the
+   * out parameter to their values.
+   *
+   * A special parameter object is `{ kind: "error" }`, which triggers a
+   * Javascript error when the output parameter of the Wasm function points to a
+   * string and not null after the call.
+   *
+   * If `options.result === "string` the result of the Wasm function is read as a
+   * string if it is not 0.
+   */
+  callAPI(fname, args, options) {
+    let errObj = null;
+    let argObjs = args.map((arg, ix) => {
+      if (arg === null) {
+        return { kind: "in", type: "null", arg: 0 };
+      }
+      if (Number.isInteger(arg) && arg < 2 ** 32) {
+        return { kind: "in", type: "word", arg };
+      }
+      if (typeof arg === "boolean") {
+        return { kind: "in", type: "bool", arg: arg ? 1 : 0 };
+      } else if (typeof arg === "string") {
+        return { kind: "in", type: "string", arg: this.writeString(arg) };
+      } else if (arg instanceof Uint8Array) {
+        let ptr = this.allocate(arg.length);
+        let mem8 = new Uint8Array(this.mem.buffer);
+        mem8.set(arg, ptr);
+        return { kind: "in", type: "bytes", arg: ptr };
+      } else if (arg instanceof ArrayBuffer) {
+        let ptr = this.allocate(arg.byteLength);
+        let mem8 = new Uint8Array(this.mem.buffer);
+        mem8.set(new Uint8Array(arg), ptr);
+        return { kind: "in", type: "bytes", arg: ptr };
+      } else if (arg?.kind === "error") {
+        this.assert(errObj == null, "only one error output");
+        errObj = { kind: "error", arg: this.allocate(4) };
+        return errObj;
+      } else if (arg?.kind === "out") {
+        switch (arg.type) {
+          case "string":
+            return {
+              kind: "out",
+              type: "string",
+              name: arg.name,
+              arg: this.allocate(4),
+            };
+          case "bool":
+            return {
+              kind: "out",
+              type: "bool",
+              name: arg.name,
+              arg: this.allocate(1),
+            };
+          case "word":
+            return {
+              kind: "out",
+              type: "word",
+              name: arg.name,
+              arg: this.allocate(4),
+            };
+          default:
+            throw new Error(
+              `Unexpected type in argument ${ix} of ${fname}: ${arg.type}`,
+            );
+        }
+      } else {
+        throw new Error(
+          `Unexpected type or kind or value in argument ${ix} of ${fname} (type: ${typeof arg}, kind: ${arg?.kind})`,
+        );
+      }
+    });
+    let result = this.api[fname](...argObjs.map((v) => v.arg));
+    try {
+      if (errObj) {
+        let errPtr = this.readUint32(errObj.arg);
+        if (errPtr !== 0) {
+          let msg = this.readString(errPtr);
+          this.deallocate(errPtr);
+          throw new Error(`API error in ${fname}: ${msg}`);
+        }
+      }
+      let out = {};
+      for (let obj of argObjs.filter((o) => o.kind === "out")) {
+        if (!obj.name) {
+          throw new Error(`Missing name in out argument ${ix} of ${fname}`);
+        }
+        switch (obj.type) {
+          case "string":
+            let ptr = this.readUint32(obj.arg);
+            if (ptr === 0) {
+              out[obj.name] = null;
+            } else {
+              out[obj.name] = this.readDropString(ptr);
+            }
+            break;
+          case "bool":
+            out[obj.name] = this.readUint8(obj.arg) > 0;
+            break;
+          case "word":
+            out[obj.name] = this.readUint32(obj.arg);
+            break;
+          default:
+            throw new Error(
+              `Unexpected type in out argument ${ix} of ${fname}: ${obj.type}`,
+            );
+        }
+      }
+      if (options?.result?.type === "string") {
+        if (result === 0) {
+          result = null;
+        } else {
+          result = this.readDropString(result);
+        }
+      }
+      return { result, out };
+    } finally {
+      for (let obj of argObjs) {
+        switch (obj.kind) {
+          case "in":
+            switch (obj.type) {
+              case "string":
+                this.deallocate(obj.arg);
+                break;
+              case "bytes":
+                this.deallocate(obj.arg);
+                break;
+            }
+            break;
+          case "out":
+            this.deallocate(obj.arg);
+        }
+      }
+    }
+  }
+
+  /// reads a string from a pointer a pointer to a string, and deallocates the
+  /// string. returns `null` if the inner pointer is 0.
+  readDropString(ptr) {
+    if (ptr == 0) {
+      return null;
+    }
+    let res = this.readString(ptr);
+    this.deallocate(ptr);
+    return res;
+  }
+
+  readDropBytes(bytesPtr, len) {
+    let bytes = this.readUint8Buffer(bytesPtr, len);
+    this.api.mixcore_bytes_drop(bytesPtr, len);
+    return bytes;
+  }
+
+  readDropBuffer(bufPtr, len32) {
+    let res = new Uint8Array(this.mem.buffer).slice(bufPtr, bufPtr + len32 * 4);
+    this.api.mixcore_buffer_drop(bufPtr, len32);
+    return res;
+  }
+
+  assert(ok, msg) {
+    if (!ok) {
+      throw new Error(`This assertion was not met in MixCore: ${msg}`);
+    } else if (MIXCORE_TRACE && msg != "allocate") {
+      console.log(msg);
+    }
+  }
+
+  allocate(size) {
+    const res = this.api._rmx_allocate(size);
+    this.assert(res != 0, "allocate");
+    return res;
+  }
+
+  deallocate(ptr) {
+    this.api._rmx_deallocate(ptr);
+  }
+
+  writeString(str) {
+    const buf = new TextEncoder().encode(str);
+    const res = this.allocate(buf.length + 1);
+    const mem = new Uint8Array(this.mem.buffer, res, buf.length + 1);
+    mem.set(buf, 0);
+    mem[buf.length] = 0;
+    return res;
+  }
+
+  readUint8Buffer(ptr, len) {
+    return new Uint8Array(this.mem.buffer, ptr, len).slice();
+  }
+
+  writeUint8Buffer(buf) {
+    const res = this.allocate(buf.byteLength);
+    const mem = new Uint8Array(this.mem.buffer, res, buf.byteLength);
+    mem.set(buf, 0);
+    return res;
+  }
+
+  readString(ptr) {
+    const mem = new Uint8Array(this.mem.buffer, ptr);
+    const len = mem.findIndex((v) => v == 0);
+    this.assert(len != -1, "zero terminated string");
+    const buf = mem.subarray(0, len);
+    return new TextDecoder().decode(buf);
+  }
+
+  readUint32(ptr) {
+    const view = new DataView(this.mem.buffer);
+    return view.getUint32(ptr, true);
+  }
+
+  readUint8(ptr) {
+    const view = new DataView(this.mem.buffer);
+    return view.getUint8(ptr);
+  }
+
+  writeUint32(ptr, n) {
+    const view = new DataView(this.mem.buffer);
+    view.setUint32(ptr, n, true);
+  }
+
+  httpDropResponse(headersPtr, bodyPtr, bodyLen) {
+    this.deallocate(headersPtr);
+    this.deallocate(bodyPtr);
+  }
+
+  httpRequest(
+    reqUrl,
+    reqMethod,
+    reqHeaders,
+    reqBody,
+    reqBodyLen,
+    reqTimeoutMillis,
+    resStatus,
+    resHeaders,
+    resBody,
+    resBodyLen,
+    err,
+  ) {
+    let url = this.readString(reqUrl);
+    let method = this.readString(reqMethod);
+    let headers;
+    try {
+      headers = JSON.parse(this.readString(reqHeaders));
+    } catch (e) {
+      let errPtr = this.writeString("Could not parse headers: " + e);
+      this.writeUint32(err, errPtr);
+      return;
+    }
+    let body = null;
+    if (reqBody != 0) {
+      body = new Uint8Array(this.mem.buffer).subarray(
+        reqBody,
+        reqBody + reqBodyLen,
+      );
+    }
+    let req = new XMLHttpRequest(); // sync requests ftw
+    req.open(method, url, false);
+    for (let [name, value] of Object.entries(headers)) {
+      req.setRequestHeader(name, value);
+    }
+    if (reqTimeoutMillis) {
+      console.warn(
+        "ignore timeout for HTTP request (unsupported in sync XMLHTTPrequest in main thread",
+      );
+    }
+    req.send(body);
+    let response; // cannot force response type in XMLHttpRequest on main thread
+    if (req.response == null) {
+      response = null;
+    } else if (typeof req.response == "string") {
+      response = new TextEncoder().encode(req.response);
+    } else if (req.response.constructor == ArrayBuffer) {
+      response = req.response;
+    } else {
+      throw new Error(
+        `unexpected response, type ${typeof req.response}, construtor ${req.response.constructor?.name}`,
+      );
+    }
+    if (response == null) {
+      this.writeUint32(resBody, 0);
+      this.writeUint32(resBodyLen, 0);
+    } else {
+      let resBodyPtr = this.writeUint8Buffer(response);
+      this.writeUint32(resBody, resBodyPtr);
+      this.writeUint32(resBodyLen, response.byteLength);
+    }
+    let respHeaders = {};
+    for (let line of req
+      .getAllResponseHeaders()
+      .trim()
+      .split(/[\r\n]+/)) {
+      const parts = line.split(": ");
+      const header = parts.shift();
+      const value = parts.join(": ");
+      respHeaders[header] = value;
+    }
+    let resHeadersPtr = this.writeString(JSON.stringify(respHeaders));
+    this.writeUint32(resStatus, req.status);
+    this.writeUint32(resHeaders, resHeadersPtr);
+    this.writeUint32(err, 0);
+  }
+
+  // Note: filePath must be relative
+  fileUrl(filePath, url) {
+    if (this.fs && this.fs.dir) {
+      let pathStr = this.readString(filePath);
+      let path = { parts: pathStr.split("/"), is_dir: false };
+      let { entry: file, ret } = this.fs.dir.get_entry_for_path(path);
+      if (ret != 0) throw Error(`Could not get entry for ${pathStr}`);
+      // Using the file.data content as key in case the underlying file changes
+      if (file && file.data) {
+        let fname = pathStr.split("/").at(-1);
+        if (!(file.data in this.urls)) {
+          if (globalThis.ThisIsNode) {
+            this.urls[file.data] = "file:///" + file;
+          } else {
+            this.urls[file.data] = URL.createObjectURL(
+              new File([file.data], fname),
+            );
+          }
+        }
+        let urlptr = this.writeString(this.urls[file.data]);
+        this.writeUint32(url, urlptr);
+      }
+    }
+  }
+}
+
+function createWASI(wasi_shim, preopen, opts, env) {
+  let stdin = new wasi_shim.OpenFile(new wasi_shim.File([]));
+  let stdout = wasi_shim.ConsoleStdout.lineBuffered((msg) =>
+    console.log(`wasi: ${msg}`),
+  );
+  let stderr = wasi_shim.ConsoleStdout.lineBuffered((msg) =>
+    console.warn(`wasi: ${msg}`),
+  );
+  let fds = [stdin, stdout, stderr, preopen];
+  return new wasi_shim.WASI([], env ?? [], fds, opts ?? {});
+}
+
+;// ./src/mixcore-base.ts
+class Mixcore {
+}
+
+;// ./src/mixcore-wasm.ts
+
+// Mixcore FFI connector based on Wasm
+class MixcoreWasm extends Mixcore {
+    constructor(mixcorePtr, wasmApi) {
+        super();
+        this.mixcorePtr = mixcorePtr;
+        this.wasmApi = wasmApi;
+    }
+    static create(dbDir, dbName, dbUser, wasmApi) {
+        let mixcorePtr = wasmApi.mixcoreSetup(dbDir, dbName, dbUser);
+        return new MixcoreWasm(mixcorePtr, wasmApi);
+    }
+    drop() {
+        this.wasmApi.mixcoreDrop(this.mixcorePtr);
+    }
+    // JS Mixcore API
+    async ffiNames() {
+        return this.wasmApi.ffiNames(this.mixcorePtr);
+    }
+    // JS Mixcore API
+    async ffiDispatch(co, name, argsBuf) {
+        return this.wasmApi.ffiDispatch(this.mixcorePtr, co, name, argsBuf);
+    }
+    getCodes(dbDir, dbName) {
+        return this.wasmApi.mixcoreGetCodes(dbDir, dbName);
+    }
+    // used in groovebox/machine-wasm/js/common.js
+    registerDebugObject(name, bytes) {
+        this.wasmApi.registerDebugObject(name, bytes);
+    }
+}
+
+;// ./src/mixcore-tauri.ts
+
+// don't depend on the tauri library
+async function invoke(cmd, args) {
+    return await window.__TAURI__.core.invoke(cmd, args);
+}
+class MixcoreTauri extends Mixcore {
+    constructor(id) {
+        super();
+        this.id = id;
+    }
+    static async create(workspace, app) {
+        let id = (await invoke("mixcore_setup", { workspace, app }));
+        return new MixcoreTauri(id);
+    }
+    async ffiNames() {
+        return await invoke("mixcore_ffi_names", { id: this.id });
+    }
+    async ffiDispatch(co, name, argsBuf8) {
+        let argsBuf = Array.from(new Uint8Array(argsBuf8.buffer));
+        let resBuf = (await invoke("mixcore_ffi_dispatch", {
+            id: this.id,
+            co,
+            name,
+            argsBuf,
+        }));
+        return new Uint8Array(resBuf);
+    }
+}
+
+;// ./src/mixcore-webkit.ts
+
+async function handler(channel, msg) {
+    return await window.webkit.messageHandlers[channel].postMessage(msg);
+}
+class MixcoreWebkit extends Mixcore {
+    async ffiNames() {
+        return await handler("mixcore_ffi_names", {});
+    }
+    async ffiDispatch(co, name, argsBuf) {
+        return await handler("mixcore_ffi_dispatch", { co, name, argsBuf });
+    }
+}
+
+;// ./src/ffi-filter.ts
+// as long as we don't support better the dedicated groovebox setup
+// (mixcore_setup_groovebox), we may need to filter the FFIs for use in
+// groovebox
+const CORE_FFI_NAMES = [
+    "$destroyHook",
+    "$hideHook",
+    "$isSyncEnabled",
+    "$loadHook",
+    "$flush",
+    "$showHook",
+    "$log",
+    "get_env",
+    "$outputError",
+    "$outputWithVersion",
+    "$co_sleep",
+    "$decodeError",
+];
+function ffiNameMatches(name, pattern) {
+    if (pattern == "CORE") {
+        return CORE_FFI_NAMES.includes(name);
+    }
+    if (pattern.slice(-1) === "*") {
+        return name.startsWith(pattern.slice(0, -1));
+    }
+    return name === pattern;
+}
+function filterFFINames(names, enable, disable) {
+    if (enable !== undefined) {
+        names = names.filter((name) => enable.some((pat) => ffiNameMatches(name, pat)));
+    }
+    if (disable !== undefined) {
+        names = names.filter((name) => !disable.some((pat) => ffiNameMatches(name, pat)));
+    }
+    return names;
+}
+
+;// ./src/mixcore.ts
+
+
+
+
+
+async function dirName(dbName) {
+    let data = new TextEncoder().encode(dbName);
+    let digest = await crypto.subtle.digest("SHA-1", data);
+    return btoa(String.fromCharCode(...new Uint8Array(digest)))
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/\=+$/, "");
+}
+
+
+export { MixcoreTauri, MixcoreWasm, MixcoreWasmApi, MixcoreWebkit, createWASI, dirName, filterFFINames };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remix_labs/machine-starter",
-  "version": "2.3465.0-dev",
+  "version": "2.11723.0-dev",
   "description": "start the groove",
   "main": "node.js",
   "browser": "index.js",
@@ -11,7 +11,7 @@
   "author": "Remixlabs staff",
   "license": "ISC",
   "dependencies": {
-    "@remix_labs/hub-client": "2.3465.0-dev",
+    "@remix_labs/hub-client": "2.11723.0-dev",
     "nanoid": "^5.0.2",
     "web-worker": "^1.2.0"
   },