@yowasp/yosys 0.59.35-dev.1011 → 0.59.84-dev.1025

package/gen/bundle.js

@@ -1,21 +1,154 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/nanotar/dist/index.mjs
+function parseTar(data, opts) {
+  const buffer = data.buffer || data;
+  const files = [];
+  let offset = 0;
+  while (offset < buffer.byteLength - 512) {
+    const name = _readString(buffer, offset, 100);
+    if (name.length === 0) {
+      break;
+    }
+    const mode = _readString(buffer, offset + 100, 8).trim();
+    const uid = Number.parseInt(_readString(buffer, offset + 108, 8));
+    const gid = Number.parseInt(_readString(buffer, offset + 116, 8));
+    const size = _readNumber(buffer, offset + 124, 12);
+    const seek = 512 + 512 * Math.trunc(size / 512) + (size % 512 ? 512 : 0);
+    const mtime = _readNumber(buffer, offset + 136, 12);
+    const _type = _readNumber(buffer, offset + 156, 1);
+    const type = _type === TAR_TYPE_FILE ? "file" : _type === TAR_TYPE_DIR ? "directory" : _type;
+    const user = _readString(buffer, offset + 265, 32);
+    const group = _readString(buffer, offset + 297, 32);
+    const meta = {
+      name,
+      type,
+      size,
+      attrs: {
+        mode,
+        uid,
+        gid,
+        mtime,
+        user,
+        group
+      }
+    };
+    if (opts?.filter && !opts.filter(meta)) {
+      offset += seek;
+      continue;
+    }
+    if (opts?.metaOnly) {
+      files.push(meta);
+      offset += seek;
+      continue;
+    }
+    const data2 = _type === TAR_TYPE_DIR ? void 0 : new Uint8Array(buffer, offset + 512, size);
+    files.push({
+      ...meta,
+      data: data2,
+      get text() {
+        return new TextDecoder().decode(this.data);
+      }
+    });
+    offset += seek;
+  }
+  return files;
+}
+function _readString(buffer, offset, size) {
+  const view = new Uint8Array(buffer, offset, size);
+  const i = view.indexOf(0);
+  const td = new TextDecoder();
+  return td.decode(i === -1 ? view : view.slice(0, i));
+}
+function _readNumber(buffer, offset, size) {
+  const view = new Uint8Array(buffer, offset, size);
+  let str = "";
+  for (let i = 0; i < size; i++) {
+    str += String.fromCodePoint(view[i]);
+  }
+  return Number.parseInt(str, 8);
+}
+var TAR_TYPE_FILE, TAR_TYPE_DIR;
+var init_dist = __esm({
+  "node_modules/nanotar/dist/index.mjs"() {
+    TAR_TYPE_FILE = 0;
+    TAR_TYPE_DIR = 5;
+  }
+});
+
+// gen/yosys-resources.js
+var yosys_resources_exports = {};
+__export(yosys_resources_exports, {
+  filesystem: () => filesystem,
+  modules: () => modules
+});
+function unpackResources(url) {
+  function defaultFetchFn(url2) {
+    return fetch(url2).then((resp) => resp.arrayBuffer());
+  }
+  return async (fetchFn = defaultFetchFn) => {
+    const root = {};
+    for (const tarEntry of parseTar(await fetchFn(url))) {
+      const nameParts = tarEntry.name.split("/");
+      const dirNames = nameParts.slice(0, -1);
+      const fileName = nameParts[nameParts.length - 1];
+      let dir = root;
+      for (const dirName of dirNames)
+        dir = dir[dirName];
+      if (tarEntry.type === "directory") {
+        dir[fileName] = {};
+      } else {
+        dir[fileName] = tarEntry.data;
+      }
+    }
+    return root;
+  };
+}
+var modules, filesystem;
+var init_yosys_resources = __esm({
+  "gen/yosys-resources.js"() {
+    init_dist();
+    modules = {
+      "yosys.core.wasm": new URL("./yosys.core.wasm", import.meta.url),
+      "yosys.core2.wasm": new URL("./yosys.core2.wasm", import.meta.url),
+      "yosys.core3.wasm": new URL("./yosys.core3.wasm", import.meta.url),
+      "yosys.core4.wasm": new URL("./yosys.core4.wasm", import.meta.url)
+    };
+    filesystem = {
+      share: unpackResources(new URL("./yosys-resources.tar", import.meta.url))
+    };
+  }
+});
+
 // node_modules/@yowasp/runtime/lib/fetch.js
-var fetch;
+var fetch2;
 if (typeof process === "object" && process.release?.name === "node") {
-  fetch = async function(url, options) {
+  fetch2 = async function(url, options) {
     if (url.protocol === "file:") {
-      const { readFile } = await import("fs/promises");
-      let contentType = "application/octet-stream";
-      if (url.pathname.endsWith(".wasm"))
-        contentType = "application/wasm";
-      return new Response(await readFile(url), { headers: { "Content-Type": contentType } });
+      const { readFile } = await import("node:fs/promises");
+      const data = await readFile(url);
+      const isWasm = url.pathname.endsWith(".wasm");
+      const headers = {
+        "content-length": data.length,
+        "content-type": isWasm ? "application/wasm" : "application/octet-stream"
+      };
+      return new Response(data, { headers });
     } else {
       return globalThis.fetch(url, options);
     }
   };
 } else {
-  fetch = globalThis.fetch;
+  fetch2 = globalThis.fetch;
 }
-var fetch_default = fetch;
+var fetch_default = fetch2;
 
 // node_modules/@yowasp/runtime/lib/wasi-virt.js
 var Exit = class extends Error {
@@ -121,8 +254,13 @@ var TerminalInput = class {
 };
 var TerminalOutput = class {
 };
+var nextFilesystemId = /* @__PURE__ */ (function() {
+  let id = 0;
+  return () => id++;
+})();
 var File = class {
   constructor(data = "") {
+    this.id = nextFilesystemId();
     if (data instanceof Uint8Array) {
       this.data = data;
     } else if (typeof data === "string") {
@@ -135,40 +273,15 @@ var File = class {
     return this.data.length;
   }
 };
-var ReadStream = class extends InputStream {
-  constructor(file, offset) {
-    super();
-    this.file = file;
-    this.offset = offset;
-  }
-  read(len) {
-    const data = this.file.data.subarray(Number(this.offset), Number(this.offset + len));
-    this.offset += len;
-    return data;
-  }
-};
-var WriteStream = class extends OutputStream {
-  constructor(file, offset) {
-    super();
-    this.file = file;
-    this.offset = offset;
-  }
-  write(contents) {
-    const newData = new Uint8Array(this.file.data.length + contents.length);
-    newData.set(this.file.data);
-    newData.subarray(Number(this.offset)).set(contents);
-    this.file.data = newData;
-    this.offset += BigInt(contents.length);
-  }
-};
 var Directory = class _Directory {
   constructor(files = {}) {
+    this.id = nextFilesystemId();
     this.files = files;
   }
   get size() {
     return Object.keys(this.files).length;
   }
-  traverse(path, flags = { create: false, remove: false }) {
+  traverse(path, { create = null, remove = false } = {}) {
     let entry = this;
     let separatorAt = -1;
     do {
@@ -177,7 +290,7 @@ var Directory = class _Directory {
       const files = entry.files;
       separatorAt = path.indexOf("/");
       const segment = separatorAt === -1 ? path : path.substring(0, separatorAt);
-      if (separatorAt === -1 && flags.remove)
+      if (separatorAt === -1 && remove)
         delete files[segment];
       else if (segment === "" || segment === ".")
         ;
@@ -185,10 +298,12 @@ var Directory = class _Directory {
         ;
       else if (Object.hasOwn(files, segment))
         entry = files[segment];
-      else if (flags.create === "directory" || flags.create === "file" && separatorAt !== -1)
+      else if (create === "directory" || create !== null && separatorAt !== -1)
         entry = files[segment] = new _Directory({});
-      else if (flags.create === "file")
+      else if (create === "file")
         entry = files[segment] = new File(new Uint8Array());
+      else if (create instanceof File || create instanceof _Directory)
+        entry = files[segment] = create;
       else
         throw "no-entry";
       path = path.substring(separatorAt + 1);
@@ -196,6 +311,33 @@ var Directory = class _Directory {
     return entry;
   }
 };
+var ReadStream = class extends InputStream {
+  constructor(file, offset) {
+    super();
+    this.file = file;
+    this.offset = offset;
+  }
+  read(len) {
+    const data = this.file.data.subarray(Number(this.offset), Number(this.offset + len));
+    this.offset += len;
+    return data;
+  }
+};
+var WriteStream = class extends OutputStream {
+  constructor(file, offset) {
+    super();
+    this.file = file;
+    this.offset = offset;
+  }
+  write(contents) {
+    const offset = Number(this.offset);
+    const newData = new Uint8Array(Math.max(this.file.data.length, offset + contents.length));
+    newData.set(this.file.data);
+    newData.subarray(offset).set(contents);
+    this.file.data = newData;
+    this.offset += BigInt(contents.length);
+  }
+};
 var Descriptor = class _Descriptor {
   constructor(entry) {
     this.entry = entry;
@@ -210,7 +352,7 @@ var Descriptor = class _Descriptor {
     return {};
   }
   metadataHash() {
-    return { upper: 0, lower: 0 };
+    return { upper: 0, lower: this.entry.id };
   }
   metadataHashAt(_pathFlags, path) {
     if (!(this.entry instanceof Directory))
@@ -242,7 +384,7 @@ var Descriptor = class _Descriptor {
   openAt(_pathFlags, path, openFlags, _descriptorFlags) {
     if (!(this.entry instanceof Directory))
       throw "invalid";
-    const openEntry = this.entry.traverse(path, { create: openFlags.create ? "file" : false });
+    const openEntry = this.entry.traverse(path, openFlags.create ? { create: "file" } : {});
     if (openFlags.directory) {
       if (!(openEntry instanceof Directory))
         throw "not-directory";
@@ -272,6 +414,18 @@ var Descriptor = class _Descriptor {
   writeViaStream(offset) {
     return new WriteStream(this.entry, offset);
   }
+  setSize(size) {
+    if (this.entry instanceof Directory)
+      throw "is-directory";
+    size = Number(size);
+    if (size > this.entry.data.length) {
+      const newData = new Uint8Array(size);
+      newData.set(this.entry.data);
+      this.entry.data = newData;
+    } else if (size < this.entry.data.length) {
+      this.entry.data = this.entry.data.subarray(0, size);
+    }
+  }
   readDirectory() {
     return new DirectoryEntryStream(this.entry);
   }
@@ -281,15 +435,28 @@ var Descriptor = class _Descriptor {
   unlinkFileAt(path) {
     const pathEntry = this.entry.traverse(path);
     if (pathEntry instanceof Directory)
-      return "is-directory";
+      throw "is-directory";
     this.entry.traverse(path, { remove: true });
   }
   removeDirectoryAt(path) {
     const pathEntry = this.entry.traverse(path);
     if (!(pathEntry instanceof Directory))
-      return "not-directory";
+      throw "not-directory";
     this.entry.traverse(path, { remove: true });
   }
+  readlinkAt(path) {
+    const _pathEntry = this.entry.traverse(path);
+    throw "invalid";
+  }
+  renameAt(oldPath, newDescriptor, newPath) {
+    if (!(this.entry instanceof Directory))
+      throw "not-directory";
+    if (!(newDescriptor.entry instanceof Directory))
+      throw "not-directory";
+    const oldEntry = this.entry.traverse(oldPath);
+    this.entry.traverse(newPath, { create: oldEntry });
+    this.entry.traverse(oldPath, { remove: true });
+  }
 };
 var DirectoryEntryStream = class {
   constructor(directory) {
@@ -400,8 +567,7 @@ var Environment = class {
         filesystemErrorCode() {
         },
         getDirectories() {
-          if ($this.root === null)
-            return [];
+          if ($this.root === null) return [];
           return [[new Descriptor($this.root), "/"]];
         }
       }
@@ -457,6 +623,8 @@ async function fetchObject(obj, fetchFn) {
       promises.push(Promise.resolve([key, value]));
     } else if (value instanceof URL) {
       promises.push(fetchFn(value).then((fetched) => [key, fetched]));
+    } else if (value instanceof Function) {
+      promises.push(await value(fetchFn).then((fetched) => [key, fetched]));
     } else {
       promises.push(fetchObject(value, fetchFn).then((fetched) => [key, fetched]));
     }
@@ -465,43 +633,92 @@ async function fetchObject(obj, fetchFn) {
     obj[key] = value;
   return obj;
 }
-function fetchWebAssembly(url) {
-  return fetch_default(url).then(WebAssembly.compileStreaming);
+function fetchWebAssembly(url, monitorProgress) {
+  const response = fetch_default(url).then(monitorProgress);
+  if (WebAssembly.compileStreaming !== void 0) {
+    return response.then(WebAssembly.compileStreaming);
+  } else {
+    return response.then((resp) => resp.arrayBuffer()).then(WebAssembly.compile);
+  }
 }
-function fetchUint8Array(url) {
-  return fetch_default(url).then((resp) => resp.arrayBuffer()).then((buf) => new Uint8Array(buf));
+function fetchUint8Array(url, monitorProgress) {
+  const response = fetch_default(url).then(monitorProgress);
+  return response.then((resp) => resp.arrayBuffer()).then((buf) => new Uint8Array(buf));
 }
-function fetchResources({ modules, filesystem }) {
+function fetchResources({ modules: modules2, filesystem: filesystem2 }, fetchProgress, application) {
+  let monitorProgress = (response) => response;
+  if (fetchProgress !== void 0) {
+    const progress = /* @__PURE__ */ new Map();
+    const notifyProgress = () => {
+      let cumTotalLength = 0, cumDoneLength = 0;
+      for (const { totalLength, doneLength } of progress.values()) {
+        cumTotalLength += totalLength;
+        cumDoneLength += doneLength;
+      }
+      fetchProgress({
+        source: application,
+        totalLength: cumTotalLength,
+        doneLength: cumDoneLength
+      });
+    };
+    monitorProgress = (response) => {
+      let totalLength = +response.headers.get("content-length");
+      let doneLength = 0;
+      progress.set(response, { totalLength, doneLength });
+      notifyProgress();
+      const monitorStream = new TransformStream({
+        transform(chunk, controller) {
+          controller.enqueue(chunk);
+          doneLength += chunk.length;
+          progress.set(response, { totalLength, doneLength });
+          notifyProgress();
+        }
+      });
+      return new Response(response.body.pipeThrough(monitorStream), response);
+    };
+  }
   return Promise.all([
-    fetchObject(modules, fetchWebAssembly),
-    fetchObject(filesystem, fetchUint8Array)
-  ]).then(([modules2, filesystem2]) => {
-    return { modules: modules2, filesystem: filesystem2 };
+    fetchObject(modules2, (url) => fetchWebAssembly(url, monitorProgress)),
+    fetchObject(filesystem2, (url) => fetchUint8Array(url, monitorProgress))
+  ]).then(([modules3, filesystem3]) => {
+    return { modules: modules3, filesystem: filesystem3 };
   });
 }
 var Application = class {
+  #resources;
+  #resourceData;
+  #instantiate;
+  #argv0;
   constructor(resources, instantiate2, argv0) {
-    this.resources = resources;
-    this.resourceData = null;
-    this.instantiate = instantiate2;
-    this.argv0 = argv0;
+    this.#resources = resources;
+    this.#resourceData = null;
+    this.#instantiate = instantiate2;
+    this.#argv0 = argv0;
+  }
+  get argv0() {
+    return this.#argv0;
   }
   // The `printLine` option is deprecated and not documented but still accepted for compatibility.
   run(args = null, files = {}, options = {}) {
-    if (this.resourceData === null) {
+    if (this.#resourceData === null) {
       if (options.synchronously)
         throw new Error("Cannot run application synchronously unless resources are prefetched first; use `await run()` to do so");
-      return this.resources().then(fetchResources).then((resourceData) => {
-        this.resourceData = resourceData;
+      const defaultFetchProgress = ({ source, totalLength, doneLength }) => {
+        const percent = (100 * doneLength / totalLength).toFixed(0);
+        console.log(`${source.argv0}: fetched ${percent}% (${doneLength} / ${totalLength})`);
+      };
+      const fetchProgress = options.fetchProgress ?? defaultFetchProgress;
+      return this.#resources().then((resourceObject) => fetchResources(resourceObject, fetchProgress, this)).then((resourceData) => {
+        this.#resourceData = resourceData;
         return this.run(args, files, options);
       });
     }
     if (args === null)
       return;
     const environment = new Environment();
-    environment.args = [this.argv0].concat(args);
+    environment.args = [this.#argv0].concat(args);
     environment.root = directoryFromTree(files);
-    for (const [dirName, dirContents] of Object.entries(this.resourceData.filesystem))
+    for (const [dirName, dirContents] of Object.entries(this.#resourceData.filesystem))
       environment.root.files[dirName] = directoryFromTree(dirContents);
     const lineBufferedConsole = lineBuffered(options.printLine ?? console.log);
     environment.stdin = options.stdin === void 0 ? null : options.stdin;
@@ -517,7 +734,7 @@ var Application = class {
         if (e instanceof Exit && e.code !== 0)
           error = e;
       }
-      for (const dirName of Object.keys(this.resourceData.filesystem))
+      for (const dirName of Object.keys(this.#resourceData.filesystem))
         delete environment.root.files[dirName];
       files = directoryIntoTree(environment.root, { decodeASCII: options.decodeASCII ?? true });
       if (error !== null) {
@@ -527,13 +744,13 @@ var Application = class {
         return files;
       }
     };
-    const getCoreModule = (filename) => this.resourceData.modules[filename];
+    const getCoreModule = (filename) => this.#resourceData.modules[filename];
     const imports = { runtime: environment.exports };
     if (options.synchronously) {
       const instantiateCore = (module, imports2) => new WebAssembly.Instance(module, imports2);
-      return runCommand(this.instantiate(getCoreModule, imports, instantiateCore));
+      return runCommand(this.#instantiate(getCoreModule, imports, instantiateCore));
     } else {
-      return this.instantiate(getCoreModule, imports).then(runCommand);
+      return this.#instantiate(getCoreModule, imports).then(runCommand);
     }
   }
 };
@@ -550,10 +767,8 @@ var curResourceBorrows = [];
 var dv = new DataView(new ArrayBuffer());
 var dataView = (mem) => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
 function getErrorPayload(e) {
-  if (e && hasOwnProperty.call(e, "payload"))
-    return e.payload;
-  if (e instanceof Error)
-    throw e;
+  if (e && hasOwnProperty.call(e, "payload")) return e.payload;
+  if (e instanceof Error) throw e;
   return e;
 }
 var handleTables = [];
@@ -576,8 +791,7 @@ function rscTableRemove(table, handle) {
   const val = table[(handle << 1) + 1];
   const own = (val & T_FLAG) !== 0;
   const rep = val & ~T_FLAG;
-  if (val === 0 || (scope & T_FLAG) !== 0)
-    throw new TypeError("Invalid handle");
+  if (val === 0 || (scope & T_FLAG) !== 0) throw new TypeError("Invalid handle");
   table[handle << 1] = table[0] | T_FLAG;
   table[0] = handle | T_FLAG;
   return { rep, scope, own };
@@ -594,8 +808,7 @@ var utf8Decoder = new TextDecoder();
 var utf8Encoder = new TextEncoder();
 var utf8EncodedLen = 0;
 function utf8Encode(s, realloc, memory) {
-  if (typeof s !== "string")
-    throw new TypeError("expected a string");
+  if (typeof s !== "string") throw new TypeError("expected a string");
   if (s.length === 0) {
     utf8EncodedLen = 0;
     return 1;
@@ -645,7 +858,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
   } = monotonicClock;
   const { getRandomBytes } = random;
   const { now: now$1 } = wallClock;
-  let gen = function* init() {
+  let gen = (function* init() {
     let exports0;
     let exports1;
     function trampoline0() {
@@ -5090,8 +5303,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
       if (handleEntry.own) {
         const rsc = captureTable7.get(handleEntry.rep);
         if (rsc) {
-          if (rsc[symbolDispose])
-            rsc[symbolDispose]();
+          if (rsc[symbolDispose]) rsc[symbolDispose]();
           captureTable7.delete(handleEntry.rep);
         } else if (DirectoryEntryStream2[symbolCabiDispose]) {
           DirectoryEntryStream2[symbolCabiDispose](handleEntry.rep);
@@ -5103,8 +5315,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
       if (handleEntry.own) {
         const rsc = captureTable3.get(handleEntry.rep);
         if (rsc) {
-          if (rsc[symbolDispose])
-            rsc[symbolDispose]();
+          if (rsc[symbolDispose]) rsc[symbolDispose]();
           captureTable3.delete(handleEntry.rep);
         } else if (OutputStream2[symbolCabiDispose]) {
           OutputStream2[symbolCabiDispose](handleEntry.rep);
@@ -5116,8 +5327,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
       if (handleEntry.own) {
         const rsc = captureTable0.get(handleEntry.rep);
         if (rsc) {
-          if (rsc[symbolDispose])
-            rsc[symbolDispose]();
+          if (rsc[symbolDispose]) rsc[symbolDispose]();
           captureTable0.delete(handleEntry.rep);
         } else if (Error$1[symbolCabiDispose]) {
           Error$1[symbolCabiDispose](handleEntry.rep);
@@ -5129,8 +5339,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
       if (handleEntry.own) {
         const rsc = captureTable2.get(handleEntry.rep);
         if (rsc) {
-          if (rsc[symbolDispose])
-            rsc[symbolDispose]();
+          if (rsc[symbolDispose]) rsc[symbolDispose]();
           captureTable2.delete(handleEntry.rep);
         } else if (InputStream2[symbolCabiDispose]) {
           InputStream2[symbolCabiDispose](handleEntry.rep);
@@ -5142,8 +5351,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
       if (handleEntry.own) {
         const rsc = captureTable6.get(handleEntry.rep);
         if (rsc) {
-          if (rsc[symbolDispose])
-            rsc[symbolDispose]();
+          if (rsc[symbolDispose]) rsc[symbolDispose]();
           captureTable6.delete(handleEntry.rep);
         } else if (Descriptor2[symbolCabiDispose]) {
           Descriptor2[symbolCabiDispose](handleEntry.rep);
@@ -5155,8 +5363,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
       if (handleEntry.own) {
         const rsc = captureTable1.get(handleEntry.rep);
         if (rsc) {
-          if (rsc[symbolDispose])
-            rsc[symbolDispose]();
+          if (rsc[symbolDispose]) rsc[symbolDispose]();
           captureTable1.delete(handleEntry.rep);
         } else if (Pollable[symbolCabiDispose]) {
           Pollable[symbolCabiDispose](handleEntry.rep);
@@ -5168,8 +5375,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
       if (handleEntry.own) {
         const rsc = captureTable4.get(handleEntry.rep);
         if (rsc) {
-          if (rsc[symbolDispose])
-            rsc[symbolDispose]();
+          if (rsc[symbolDispose]) rsc[symbolDispose]();
           captureTable4.delete(handleEntry.rep);
         } else if (TerminalInput2[symbolCabiDispose]) {
           TerminalInput2[symbolCabiDispose](handleEntry.rep);
@@ -5181,8 +5387,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
       if (handleEntry.own) {
         const rsc = captureTable5.get(handleEntry.rep);
         if (rsc) {
-          if (rsc[symbolDispose])
-            rsc[symbolDispose]();
+          if (rsc[symbolDispose]) rsc[symbolDispose]();
           captureTable5.delete(handleEntry.rep);
         } else if (TerminalOutput2[symbolCabiDispose]) {
           TerminalOutput2[symbolCabiDispose](handleEntry.rep);
@@ -5411,7 +5616,7 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
       run
     };
     return { run: run020, "wasi:cli/run@0.2.0": run020 };
-  }();
+  })();
   let promise, resolve, reject;
   function runNext(value) {
     try {
@@ -5420,19 +5625,14 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
         ({ value, done } = gen.next(value));
       } while (!(value instanceof Promise) && !done);
       if (done) {
-        if (resolve)
-          resolve(value);
-        else
-          return value;
+        if (resolve) resolve(value);
+        else return value;
       }
-      if (!promise)
-        promise = new Promise((_resolve, _reject) => (resolve = _resolve, reject = _reject));
+      if (!promise) promise = new Promise((_resolve, _reject) => (resolve = _resolve, reject = _reject));
       value.then((nextVal) => done ? resolve() : runNext(nextVal), reject);
     } catch (e) {
-      if (reject)
-        reject(e);
-      else
-        throw e;
+      if (reject) reject(e);
+      else throw e;
     }
   }
   const maybeSyncReturn = runNext(null);
@@ -5440,10 +5640,10 @@ function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.insta
 }
 
 // lib/api.js
-var yosys = new Application(() => import("./resources-yosys.js"), instantiate, "yowasp-yosys");
+var yosys = new Application(() => Promise.resolve().then(() => (init_yosys_resources(), yosys_resources_exports)), instantiate, "yowasp-yosys");
 var runYosys = yosys.run.bind(yosys);
 var commands = { "yosys": runYosys };
-var version = "0.59.35-dev.1011";
+var version = "0.59.84-dev.1025";
 export {
   Exit,
   commands,

package/lib/api.d.ts

@@ -8,12 +8,16 @@ export type InputStream =
 export type OutputStream =
     (bytes: Uint8Array | null) => void;
 
+export type ProgressCallback =
+    (event: { source: object, totalLength: number, doneLength: number }) => void;
+
 export type RunOptions = {
     stdin?:  InputStream  | null;
     stdout?: OutputStream | null;
     stderr?: OutputStream | null;
     decodeASCII?: boolean;
     synchronously?: boolean;
+    fetchProgress?: ProgressCallback;
 };
 
 export type Command =