@ai-ecoverse/slicc-kernel 1.8.0 → 1.8.2

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`. 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 module with no WASI imports, or a foreign import that is not a function, is still refused (126). `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);
@@ -208,6 +208,8 @@ Unit tests live in `test/unit/`, which stays out of git. They run real wasm bash
 
 The Biome, TypeScript, lefthook, Renovate and CI configuration comes from [slicc-shared-web](https://github.com/ai-ecoverse/slicc-shared-web), which also provides the `slicc-lint-comments` (no comments anywhere), `slicc-no-unit-tests` (no unit tests in git) and `slicc-diff-cover` (100% coverage of changed lines) commands that `npm run lint` and the pre-commit hook use.
 
+Releases are cut by semantic-release on every push to `main`. A failure after the version is tagged (a rejected push, a failed `npm publish`) doesn't strand that version: `tools/release-recover.mjs` runs next. For any version tagged at HEAD, it first pushes the tag if origin lacks it, then publishes the version if npm lacks it, with retries, and creates its GitHub release if that is missing too. Re-running the Release workflow completes such a version the same way.
+
 ## License
 
 Apache-2.0

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 } : {}
     };