@ai-ecoverse/slicc-kernel 1.7.2 → 1.8.1

package/README.md

@@ -109,7 +109,7 @@ A WASI program runs in a process worker of its own like an Emscripten one, again
 
 ### Program imports
 
-A WASI command can name an ES module of its package that provides imports of its own, for host functions a program needs beyond WASI (`"imports": "host/pnpm-host.mjs"`). Each worker of the process (the process and every thread) loads it, with the same trust as Emscripten glue, and calls its `createImports(ctx)`, which returns import namespaces (`{ pnpm_host: { … } }`). It may not define `wasi_snapshot_preview1`, `wasix_32v1`, `wasi` or `env`; any other namespace the module imports is then accepted, and functions it does not provide answer `ENOSYS`. `ctx` has:
+A WASI command can name an ES module of its package that provides imports of its own, for host functions a program needs beyond WASI (`"imports": "host/pnpm-host.mjs"`). Each worker of the process (the process and every thread) loads it, with the same trust as Emscripten glue, and calls its `createImports(ctx)`, which returns import namespaces (`{ pnpm_host: { … } }`). It may not define `wasi_snapshot_preview1`, `wasix_32v1`, `wasi` or `env`; any other namespace the module imports is then accepted, and functions it does not provide answer `ENOSYS`. A WASI program (one that imports `wasi_snapshot_preview1` or `wasix_32v1`) needs no imports module for that: without one, its function imports from namespaces of its own all answer `ENOSYS`, so the same binary runs the commands that need no host functions anywhere. A stub answers in the import's own result type: 52 for `i32`, `f32` and `f64`, `52n` for `i64`, and nothing for a function without a result. An import whose result cannot carry an errno (several values, `v128`, a reference) is refused (126) unless the imports module provides it. A module with no WASI imports, or a foreign import that is not a function, is still refused (126). `ctx` has:
 
 - `memory()`, `instance()` (after instantiation), `tid` (1 for the main thread), `argv`, `env`, `cwd()`;
 - `fs`: the synchronous filesystem the WASI calls use (absolute paths);

package/dist/kernel-worker.js

@@ -5544,6 +5544,109 @@ function importedMemory(bytes) {
   }
   return void 0;
 }
+var RESERVED_NAMESPACES = /* @__PURE__ */ new Set([
+  "wasi_snapshot_preview1",
+  "wasix_32v1",
+  "wasi",
+  "env"
+]);
+var RESULTS = {
+  127: "i32",
+  126: "i64",
+  125: "f32",
+  124: "f64"
+};
+function resultOf(results) {
+  if (results.length === 0) return "none";
+  return results.length === 1 && RESULTS[results[0]] || "other";
+}
+var Reader = class {
+  at = 8;
+  bytes;
+  constructor(bytes) {
+    this.bytes = bytes;
+  }
+  byte() {
+    return this.bytes[this.at++];
+  }
+  u32() {
+    let result = 0;
+    let shift = 0;
+    for (; ; ) {
+      const b = this.byte();
+      result |= (b & 127) << shift;
+      if (!(b & 128)) return result >>> 0;
+      shift += 7;
+    }
+  }
+  name() {
+    const len = this.u32();
+    const s = new TextDecoder().decode(this.bytes.subarray(this.at, this.at + len));
+    this.at += len;
+    return s;
+  }
+  valtype() {
+    const code = this.byte();
+    if (code === 99 || code === 100) this.u32();
+    return code;
+  }
+  limits() {
+    const flags = this.byte();
+    this.u32();
+    if (flags & 1) this.u32();
+  }
+};
+function readTypes(r) {
+  const types = [];
+  for (let i = r.u32(); i > 0; i--) {
+    if (r.byte() !== 96) return void 0;
+    for (let n = r.u32(); n > 0; n--) r.valtype();
+    const results = [];
+    for (let n = r.u32(); n > 0; n--) results.push(r.valtype());
+    types.push(resultOf(results));
+  }
+  return types;
+}
+function skipImport(r, kind) {
+  if (kind === 1) {
+    r.valtype();
+    r.limits();
+  } else if (kind === 2) r.limits();
+  else if (kind === 3) {
+    r.valtype();
+    r.byte();
+  } else {
+    r.byte();
+    r.u32();
+  }
+}
+function readImports(r, types) {
+  const foreign = {};
+  for (let i = r.u32(); i > 0; i--) {
+    const module = r.name();
+    const field = r.name();
+    const kind = r.byte();
+    if (kind !== 0) skipImport(r, kind);
+    else {
+      const type = types[r.u32()] ?? "other";
+      if (!RESERVED_NAMESPACES.has(module)) (foreign[module] ??= {})[field] = type;
+    }
+  }
+  return foreign;
+}
+function foreignImports(bytes) {
+  const r = new Reader(bytes);
+  let types = [];
+  while (r.at < bytes.length) {
+    const id = r.byte();
+    const end = r.u32() + r.at;
+    if (id === 1) types = readTypes(r);
+    if (!types) return void 0;
+    if (id === 2) return readImports(r, types);
+    r.at = end;
+  }
+  return {};
+}
 
 // src/launcher.ts
 var COMMAND2 = /^\/(?:usr\/)?bin\/([^/]+)$/;
@@ -5731,8 +5834,13 @@ var Launcher = class {
       if (!module) {
         module = this.base.readFileBuffer(path).then(async (bytes) => {
           const memory = importedMemory(bytes);
+          const foreign = foreignImports(bytes);
           const compiled = await WebAssembly.compile(bytes);
-          return { module: compiled, ...memory ? { memory } : {} };
+          return {
+            module: compiled,
+            ...memory ? { memory } : {},
+            foreign
+          };
         });
         this.compiled.set(key, module);
         module.catch(() => this.compiled.delete(key));
@@ -5757,7 +5865,7 @@ var Launcher = class {
       ]);
       return { glue, module: module2 };
     }
-    const { module, memory } = await this.module(target.wasm);
+    const { module, memory, foreign } = await this.module(target.wasm);
     const names = env.SLICC_WASM_BACKTRACE === "1" ? await this.names(target.wasm, module) : void 0;
     const imports = target.imports ? await this.base.readFile(target.imports) : void 0;
     return {
@@ -5765,6 +5873,7 @@ var Launcher = class {
       glue: "",
       module,
       ...memory ? { memory } : {},
+      foreign,
       ...names ? { names } : {},
       ...imports !== void 0 ? { imports } : {}
     };