@ai-ecoverse/slicc-kernel 1.54.3 → 1.54.4

package/dist/node-process-worker.js

@@ -9900,12 +9900,22 @@ var init_wasix_linker = __esm({
         if (this.mainPath === void 0) return false;
         if (path === this.mainPath) return true;
         const real = this.host.real;
-        return real !== void 0 && real(path) === real(this.mainPath);
+        if (real === void 0) return false;
+        try {
+          return real(path) === real(this.mainPath);
+        } catch {
+          return false;
+        }
       }
       open(name2, cwd, ldPath) {
         const path = this.locate(name2, cwd, ldPath);
         if (this.isMain(path)) return 0;
-        return this.load(path, cwd, ldPath).handle;
+        this.indices?.lock();
+        try {
+          return this.load(path, cwd, ldPath).handle;
+        } finally {
+          this.indices?.unlock();
+        }
       }
       symbol(handle, name2) {
         const found = handle === 0 ? this.find(name2) : this.findIn(this.module(handle), name2, /* @__PURE__ */ new Set());
@@ -9927,15 +9937,17 @@ var init_wasix_linker = __esm({
       allocateClosure() {
         const index2 = this.indices.allocate(this.table.length);
         growTable(this.table, index2 + 1);
+        this.live.add(index2);
         return index2;
       }
       freeClosure(index2) {
         this.indices?.free(index2);
+        this.live.delete(index2);
         this.table.set(index2, null);
       }
+      live = /* @__PURE__ */ new Set();
       prepareClosure(record) {
-        if (record.index >= this.table.length)
-          throw new DlError(`closure ${record.index}: no such slot`);
+        if (!this.live.has(record.index)) throw new DlError(`closure ${record.index}: not allocated`);
         const full = { kind: "closure-prepare", ...record };
         this.install(full);
         this.publisher?.(full);
@@ -9952,15 +9964,23 @@ var init_wasix_linker = __esm({
         this.table.set(record.index, fn);
         this.types.set(fn, sig);
       }
+      reserveLoad(size) {
+        return this.indices?.load(this.table.length, size) ?? {
+          base: this.table.length,
+          handle: this.nextHandle++
+        };
+      }
       reserve(size) {
         return this.indices?.reserve(this.table.length, size) ?? this.table.length;
       }
       replay(record) {
         if (record.kind === "closure") {
           growTable(this.table, record.index + 1);
+          this.live.add(record.index);
           return;
         }
         if (record.kind === "closure-free") {
+          this.live.delete(record.index);
           if (record.index < this.table.length) this.table.set(record.index, null);
           return;
         }
@@ -9970,7 +9990,8 @@ var init_wasix_linker = __esm({
         }
         if (record.kind === "load") {
           if (this.modules.has(record.handle)) return;
-          this.instantiate(record.path, this.moduleAt(record.path), record, false);
+          const linked = this.instantiate(record.path, this.moduleAt(record.path), record, false);
+          linked.needed.push(...record.needed ?? []);
           this.nextHandle = Math.max(this.nextHandle, record.handle + 1);
           return;
         }
@@ -10020,13 +10041,14 @@ var init_wasix_linker = __esm({
           (n) => this.load(this.locate(n, cwd, search), cwd, ldPath).handle
         );
         const memoryBase = this.allocate(info.memorySize, 2 ** info.memoryAlign);
-        const tableBase = this.reserve(info.tableSize);
+        const { base: tableBase, handle } = this.reserveLoad(info.tableSize);
         const record = {
           kind: "load",
-          handle: this.nextHandle++,
+          handle,
           path,
           memoryBase,
-          tableBase
+          tableBase,
+          ...needed.length > 0 ? { needed } : {}
         };
         const linked = this.instantiate(path, module, record, true);
         linked.needed.push(...needed);
@@ -10084,7 +10106,8 @@ var init_wasix_linker = __esm({
         linked.instance = new WebAssembly.Instance(module, imports);
         this.types.register(() => this.host.read(path), linked.instance, this.table, at.tableBase);
         this.modules.set(at.handle, linked);
-        this.byPath.set(path, linked);
+        const first = this.byPath.get(path);
+        if (!first || at.handle < first.handle) this.byPath.set(path, linked);
         for (const resolve of pending) resolve();
         if (init) {
           call(linked.instance, "__wasm_apply_data_relocs");
@@ -10764,6 +10787,7 @@ var init_wasix_host = __esm({
         return {
           dlopen: (p, pl, _flags, buf, len, lp, ll, out) => {
             if (p === 0) {
+              if (!this.linker) return failed4("not a dynamically-linked program", buf, len);
               mem.view().setUint32(out, MAIN_HANDLE, true);
               return E.SUCCESS;
             }
@@ -10780,7 +10804,7 @@ var init_wasix_host = __esm({
             (l) => l.symbol(handle === MAIN_HANDLE ? 0 : handle, this.str(s, sl)),
             (v) => void mem.view().setUint32(out, v, true)
           ),
-          dl_invalid_handle: (handle) => handle === MAIN_HANDLE || handle !== 0 && this.linker && !this.linker.invalid(handle) ? E.SUCCESS : E.NOEXEC
+          dl_invalid_handle: (handle) => this.linker && (handle === MAIN_HANDLE || handle !== 0 && !this.linker.invalid(handle)) ? E.SUCCESS : E.NOEXEC
         };
       }
       threadImports() {
@@ -10945,6 +10969,7 @@ var init_wasm_names = __esm({
 var wasi_runtime_exports = {};
 __export(wasi_runtime_exports, {
   FALLBACK_MAXIMUM_PAGES: () => FALLBACK_MAXIMUM_PAGES,
+  LinkSync: () => LinkSync,
   captureBacktraces: () => captureBacktraces,
   createImportedMemory: () => createImportedMemory,
   runWasiProcess: () => runWasiProcess,
@@ -11117,7 +11142,7 @@ async function instantiate(host, module, memory, threads, {
       thread
     ),
     (req) => host.o.kernel.call(req),
-    threads?.ids
+    threads
   ) : void 0;
   if (sync) {
     ({ preview1, wasix } = sync.guard(preview1, wasix));
@@ -11429,32 +11454,59 @@ var init_wasi_runtime = __esm({
       linker;
       call;
       ids;
-      constructor(linker, call2, ids) {
+      owner;
+      constructor(linker, call2, threads) {
         this.linker = linker;
         this.call = call2;
-        this.ids = ids;
+        this.ids = threads?.ids;
+        this.owner = threads?.tid ?? 0;
         linker.publisher = (record) => this.publish(record);
         linker.indices = {
           reserve: (floor, size) => this.call({ op: "dl-reserve", floor, size }),
+          load: (floor, size) => this.call({ op: "dl-load-reserve", floor, size }),
+          lock: () => {
+            this.call({ op: "dl-lock", owner: this.owner });
+            try {
+              this.catchUp();
+            } catch (e) {
+              this.call({ op: "dl-unlock", owner: this.owner });
+              throw e;
+            }
+          },
+          unlock: () => this.call({ op: "dl-unlock", owner: this.owner }),
           allocate: (floor) => {
             const index2 = this.call({ op: "dl-closure", floor });
             this.catchUp();
+            this.bump();
             return index2;
           },
-          free: (index2) => void this.call({ op: "dl-closure-free", index: index2 })
+          free: (index2) => {
+            this.call({ op: "dl-closure-free", index: index2 });
+            this.bump();
+          }
         };
       }
+      bump() {
+        if (this.ids) Atomics.add(this.ids, DL_GEN, 1);
+      }
       publish(record) {
         const since = this.call({ op: "dl-log", append: record, from: this.count });
         for (const r of since.slice(0, -1)) this.linker.replay(r);
         this.count += since.length;
-        if (this.ids) this.gen = Atomics.add(this.ids, DL_GEN, 1) + 1;
+        this.bump();
+        this.catchUp();
       }
       catchUp() {
-        const since = this.call({ op: "dl-log", from: this.count });
-        for (const r of since) this.linker.replay(r);
-        this.count += since.length;
-        if (this.ids) this.gen = Atomics.load(this.ids, DL_GEN);
+        for (; ; ) {
+          const gen = this.ids ? Atomics.load(this.ids, DL_GEN) : 0;
+          const since = this.call({ op: "dl-log", from: this.count });
+          for (const r of since) this.linker.replay(r);
+          this.count += since.length;
+          if (!this.ids || Atomics.load(this.ids, DL_GEN) === gen) {
+            this.gen = gen;
+            return;
+          }
+        }
       }
       guard(preview1, wasix) {
         const ids = this.ids;