@ai-ecoverse/slicc-kernel 1.8.0 → 1.8.2

package/dist/node.js

@@ -5248,6 +5248,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\/([^/]+)$/;
@@ -5435,8 +5538,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));
@@ -5461,7 +5569,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 {
@@ -5469,6 +5577,7 @@ var Launcher = class {
       glue: "",
       module,
       ...memory ? { memory } : {},
+      foreign,
       ...names ? { names } : {},
       ...imports !== void 0 ? { imports } : {}
     };