@lincyaw/addon-exec-wasi 0.0.0-stage → 1.0.0-rc.10

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/LICENSES

@@ -0,0 +1,326 @@
+Licenses of the WebAssembly runtimes in this directory
+=======================================================
+
+Presmium publishes these files with a deck whose code runs C, C++, Ruby or
+SQL in the browser (only the runtimes that code needs). They are the
+binaries of the Runno project as @runno/sandbox 0.10.2 ships them
+(https://runno.dev, https://github.com/taybenlor/runno), unchanged:
+
+clang.wasm, wasm-ld.wasm, clang-fs.tar.gz
+    Clang and wasm-ld of LLVM 8.0.1, and a WASI sysroot (wasi-libc,
+    libc++, libc++abi and the compiler runtime of LLVM).
+    LLVM 8: the University of Illinois/NCSA Open Source License (below);
+    libc++ and libc++abi are also under the MIT License. LLVM 9 and later
+    are under the Apache License 2.0 with LLVM Exceptions (below), as is
+    wasi-libc (also under the Apache License 2.0 or the MIT License; its
+    musl part under the MIT License).
+    https://releases.llvm.org/8.0.1/LICENSE.TXT
+    https://github.com/WebAssembly/wasi-libc/blob/main/LICENSE
+
+ruby-3.2.0.wasm, ruby-3.2.0.tar.gz
+    Ruby 3.2.0 (ruby.wasm). Ruby is copyrighted free software by Yukihiro
+    Matsumoto, under the 2-clause BSD License (below) or the Ruby License.
+    https://www.ruby-lang.org/en/about/license.txt
+
+sqlite.wasm
+    SQLite, in the public domain:
+        The author disclaims copyright to this source code. In place of
+        a legal notice, here is a blessing:
+            May you do good and not evil.
+            May you find forgiveness for yourself and forgive others.
+            May you share freely, never taking more than you give.
+    https://sqlite.org/copyright.html
+
+The Runno project (@runno/sandbox, @runno/wasi), under the MIT License:
+
+    MIT License
+
+    Copyright (c) Benjamin Taylor (me@taybenlor.com) and its affiliates.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+
+
+==============================================================================
+University of Illinois/NCSA Open Source License (LLVM 8)
+==============================================================================
+
+Copyright (c) 2003-2019 University of Illinois at Urbana-Champaign.
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
+
+
+==============================================================================
+2-clause BSD License (Ruby)
+==============================================================================
+
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+
+==============================================================================
+Apache License 2.0 with LLVM Exceptions (LLVM 9 and later, wasi-libc)
+==============================================================================
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+
+---- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.

package/README.md

@@ -1,3 +1,33 @@
-# Temporary Holding Version
+# @lincyaw/addon-exec-wasi
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Running C, C++, Ruby and SQL in WebAssembly, with the same runtime at build time and in the browser: no toolchain on the build machine, offline in the browser.
+
+Part of [Presmium](https://github.com/Lincyaw/presmium), which compiles canonical lecture.json teaching documents into web pages, slides, Jupyter notebooks and narrated playback.
+
+## Install
+
+```sh
+pnpm add -D @lincyaw/addon-exec-wasi
+```
+
+Add this package to `metadata.plugins` in the document's `lecture.json`.
+
+It is a Presmium plugin: its components work on the web page and in the slides. It needs `@lincyaw/cli` and the renderers in the same project, and declares the Presmium packages it shares with them as peer dependencies (Presmium 1.x).
+
+## What it provides
+
+- The executor `presmium.wasi` for code blocks in `c`, `cpp`, `ruby` and `sql`.
+- Named environments of `kind: wasi`.
+
+## Configuration
+
+`presmium.execWasi.loadTimeoutMs`: how long the browser may take to download a runtime (default 120000). Only code run in the browser makes the build publish the runtime (about 52 MB for C and C++).
+
+## Documentation
+
+- [Author guide](https://github.com/Lincyaw/presmium/blob/main/site/guide/locales/en/lecture.json) (Chinese: `site/guide/lecture.json`)
+- [Document contract](https://github.com/Lincyaw/presmium/blob/main/.agents/skills/presmium-author/references/document.md): normalized entities, parameters, states and shared validation
+
+## License
+
+Apache-2.0

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@lincyaw/addon-exec-wasi",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-rc.10",
+  "description": "Presmium plugin: run C, C++, Ruby and SQLite programs in WebAssembly, in the browser and at build time",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lincyaw/presmium.git",
+    "directory": "packages/addon-exec-wasi"
+  },
+  "homepage": "https://github.com/Lincyaw/presmium/tree/main/packages/addon-exec-wasi#readme",
+  "bugs": "https://github.com/Lincyaw/presmium/issues",
+  "keywords": [
+    "presmium"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=22.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./domain": "./src/domain/index.ts",
+    "./client": "./src/client/index.ts",
+    "./presmium": "./src/node/presmium.ts",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "LICENSES",
+    "src"
+  ],
+  "dependencies": {
+    "@runno/sandbox": "0.10.2",
+    "@runno/wasi": "0.10.0"
+  },
+  "peerDependencies": {
+    "@lincyaw/host": "^1.0.0-rc.10",
+    "@lincyaw/kernel": "^1.0.0-rc.10"
+  },
+  "devDependencies": {
+    "@lincyaw/host": "1.0.0-rc.10",
+    "@lincyaw/kernel": "1.0.0-rc.10",
+    "@lincyaw/render-notebook": "1.0.0-rc.10",
+    "@lincyaw/cli": "1.0.0-rc.10"
+  }
 }

package/src/client/env.d.ts

@@ -0,0 +1,7 @@
+interface ImportMetaEnv {
+  BASE_URL: string
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}

package/src/client/executors.ts

@@ -0,0 +1,56 @@
+import { createResidentWorker } from '@lincyaw/host'
+import { failedRun } from '@lincyaw/kernel'
+import type { Executor, RunRequest, RunResult } from '@lincyaw/kernel'
+import { DEFAULT_TIMEOUT_MS } from '../domain/index.ts'
+import { runsLanguage } from '../shared/wasi-runner.mjs'
+import { messages } from './messages.ts'
+import type { WorkerReply, WorkerRequest } from './protocol.ts'
+
+export interface WasiExecutorsOptions {
+  runtimeURL: string
+  loadTimeoutMs: number
+}
+
+/** The page's WASI executors, which share one resident Worker: it compiles each runtime once. */
+export interface WasiExecutors {
+  executor(id: string, languages?: string[]): Executor
+  dispose(): void
+}
+
+export function createWasiExecutors(options: WasiExecutorsOptions): WasiExecutors {
+  const resident = createResidentWorker<WorkerRequest, WorkerReply>({
+    start: () => new Worker(new URL('./wasi.worker.ts', import.meta.url), { type: 'module', name: 'presmium-wasi' }),
+    loadTimeoutMs: options.loadTimeoutMs,
+  })
+
+  async function run(id: string, request: RunRequest, signal?: AbortSignal): Promise<RunResult> {
+    const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS
+    const outcome = await resident.send({
+      request: { lang: request.lang, code: request.code, stdin: request.stdin, files: request.files ? { ...request.files } : undefined },
+      runtimeURL: new URL(options.runtimeURL, location.href).href,
+    }, { timeoutMs, signal })
+    const t = messages()
+    if ('failure' in outcome) {
+      switch (outcome.failure) {
+        case 'cancelled': return failedRun(id, t.cancelled, outcome.elapsedMs)
+        case 'load-timeout': return { ...failedRun(id, t.loadTimeout(options.loadTimeoutMs)), timedOut: true }
+        case 'run-timeout': return { ...failedRun(id, t.runTimeout(timeoutMs), outcome.elapsedMs), timedOut: true }
+        case 'crashed': return failedRun(id, t.crashed(outcome.error ?? ''), outcome.elapsedMs)
+      }
+    }
+    const { reply, elapsedMs } = outcome
+    if (reply.type === 'error') return failedRun(id, reply.stage === 'load' ? t.loadFailed(reply.error) : t.crashed(reply.error), elapsedMs)
+    const { stdout, stderr, exitCode, outputs } = reply.output
+    return { ok: exitCode === 0, stdout, stderr, exitCode, durationMs: elapsedMs, timedOut: false, source: 'live', executorId: id, outputs }
+  }
+
+  return {
+    executor: (id, languages) => ({
+      id,
+      runsIn: 'browser',
+      supports: lang => runsLanguage(lang, languages),
+      run: (request, signal) => run(id, request, signal),
+    }),
+    dispose: () => resident.dispose(),
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,5 @@
+export { createWasiExecutors } from './executors.ts'
+export type { WasiExecutors, WasiExecutorsOptions } from './executors.ts'
+export { MESSAGES, messages } from './messages.ts'
+export type { WasiMessages } from './messages.ts'
+export { execWasiPlugin } from './plugin.ts'

package/src/client/messages.ts

@@ -0,0 +1,26 @@
+import { currentLocale } from '@lincyaw/host'
+import type { Catalog } from '@lincyaw/host'
+
+const zhCN = {
+  cancelled: '已取消',
+  runTimeout: (ms: number) => `执行超过 ${ms} ms，已停止`,
+  loadTimeout: (ms: number) => `WebAssembly 运行时 ${ms} ms 内未加载完成，已停止`,
+  loadFailed: (error: string) => `WebAssembly 运行时加载失败：${error}`,
+  crashed: (error: string) => `WebAssembly 运行时出错：${error}`,
+}
+
+export type WasiMessages = typeof zhCN
+
+const en: WasiMessages = {
+  cancelled: 'Canceled',
+  runTimeout: ms => `Stopped after ${ms} ms`,
+  loadTimeout: ms => `The WebAssembly runtime did not load within ${ms} ms; stopped`,
+  loadFailed: error => `Couldn’t load the WebAssembly runtime: ${error}`,
+  crashed: error => `The WebAssembly runtime failed: ${error}`,
+}
+
+export const MESSAGES: Catalog<WasiMessages> = { 'zh-CN': zhCN, en }
+
+export function messages(): WasiMessages {
+  return MESSAGES[currentLocale()]
+}

package/src/client/plugin.ts

@@ -0,0 +1,35 @@
+import { siteBase } from '@lincyaw/host'
+import { environmentExecutor, EXECUTOR } from '@lincyaw/kernel'
+import type { PluginDefinition } from '@lincyaw/kernel'
+import { version } from '../../package.json'
+import { EXEC_WASI_ID, execWasiConfig, RUNTIME_DIR, WASI_EXECUTOR_ID, WASI_KIND } from '../domain/index.ts'
+import { createWasiExecutors } from './executors.ts'
+import type { WasiExecutors } from './executors.ts'
+
+let executors: WasiExecutors | undefined
+
+export const execWasiPlugin: PluginDefinition = {
+  manifest: {
+    id: EXEC_WASI_ID,
+    name: { 'zh-CN': 'WebAssembly 运行', en: 'WebAssembly Runner' },
+    version,
+    kernel: '^1.0.0',
+    requires: [{ token: EXECUTOR, optional: true }],
+    capabilities: ['exec'],
+  },
+  setup(ctx) {
+    const router = ctx.tryGet(EXECUTOR)
+    if (!router) return
+    executors?.dispose()
+    executors = createWasiExecutors({ runtimeURL: `${siteBase()}${RUNTIME_DIR}`, loadTimeoutMs: execWasiConfig(ctx.config).loadTimeoutMs })
+    router.register(executors.executor(WASI_EXECUTOR_ID))
+    for (const [name, spec] of Object.entries(ctx.environments ?? {})) {
+      if (spec.kind === WASI_KIND) router.register(executors.executor(environmentExecutor(name), spec.languages))
+    }
+  },
+  dispose() {
+    executors?.dispose()
+  },
+}
+
+export default execWasiPlugin

package/src/client/protocol.ts

@@ -0,0 +1,12 @@
+import type { WasiOutput, WasiRequest } from '../shared/wasi-runner.mjs'
+
+export interface WorkerRequest {
+  id: number
+  request: WasiRequest
+  runtimeURL: string
+}
+
+export type WorkerReply =
+  | { id: number, type: 'started' }
+  | { id: number, type: 'done', output: WasiOutput }
+  | { id: number, type: 'error', stage: 'load' | 'run', error: string }

package/src/client/wasi.worker.ts

@@ -0,0 +1,28 @@
+/// <reference lib="webworker" />
+import { prepare, runWasi } from '../shared/wasi-runner.mjs'
+import type { WorkerReply, WorkerRequest } from './protocol.ts'
+
+declare const self: DedicatedWorkerGlobalScope
+
+const reply = (message: WorkerReply) => self.postMessage(message)
+const reason = (error: unknown) => (error instanceof Error ? error.message : String(error))
+
+self.onmessage = async ({ data }: MessageEvent<WorkerRequest>) => {
+  const { id, request, runtimeURL } = data
+  const load = async (file: string) => {
+    const response = await fetch(new URL(file, runtimeURL))
+    if (!response.ok) throw new Error(`${file}: HTTP ${response.status}`)
+    return new Uint8Array(await response.arrayBuffer())
+  }
+  try {
+    await prepare(request.lang, load)
+  } catch (error) {
+    return reply({ id, type: 'error', stage: 'load', error: reason(error) })
+  }
+  reply({ id, type: 'started' })
+  try {
+    reply({ id, type: 'done', output: await runWasi(request, load) })
+  } catch (error) {
+    reply({ id, type: 'error', stage: 'run', error: reason(error) })
+  }
+}

package/src/domain/config.ts

@@ -0,0 +1,29 @@
+import { isRecord } from '@lincyaw/kernel'
+
+export const EXEC_WASI_ID = 'presmium.execWasi'
+
+export const WASI_EXECUTOR_ID = 'presmium.wasi'
+
+export const WASI_KIND = 'wasi'
+
+export const RUNTIME_DIR = 'wasi/'
+
+export const DEFAULT_TIMEOUT_MS = 10_000
+
+export const MEMORY_LIMIT_MB = 1024
+
+export interface ExecWasiConfig {
+  loadTimeoutMs: number
+  runtimes: string[]
+}
+
+export const DEFAULT_EXEC_WASI_CONFIG: ExecWasiConfig = { loadTimeoutMs: 120_000, runtimes: [] }
+
+export function execWasiConfig(raw: unknown): ExecWasiConfig {
+  const config = isRecord(raw) ? raw : {}
+  const load = config.loadTimeoutMs
+  return {
+    loadTimeoutMs: typeof load === 'number' && load > 0 ? load : DEFAULT_EXEC_WASI_CONFIG.loadTimeoutMs,
+    runtimes: Array.isArray(config.runtimes) ? config.runtimes.filter((r): r is string => typeof r === 'string') : [],
+  }
+}

package/src/domain/index.ts

@@ -0,0 +1,2 @@
+export { DEFAULT_EXEC_WASI_CONFIG, DEFAULT_TIMEOUT_MS, EXEC_WASI_ID, execWasiConfig, MEMORY_LIMIT_MB, RUNTIME_DIR, WASI_EXECUTOR_ID, WASI_KIND } from './config.ts'
+export type { ExecWasiConfig } from './config.ts'

package/src/node/executor.ts

@@ -0,0 +1,61 @@
+import { createRequire } from 'node:module'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { failedRun } from '@lincyaw/kernel'
+import type { Executor, RunResult } from '@lincyaw/kernel'
+import { directSandbox, RUN_REQUEST_FILE, runResultFile } from '@lincyaw/kernel/node'
+import { DEFAULT_TIMEOUT_MS, MEMORY_LIMIT_MB } from '../domain/index.ts'
+import type { WasiOutput } from '../shared/wasi-runner.mjs'
+import { runsLanguage } from '../shared/wasi-runner.mjs'
+import { runtimeDir, runtimeFingerprint } from './runtime.ts'
+
+const MAIN = fileURLToPath(new URL('./wasi-main.mjs', import.meta.url))
+const LOAD_TIMEOUT_MS = 60_000
+const RESULT = runResultFile(0)
+
+function readable(): string[] {
+  const wasi = dirname(dirname(createRequire(import.meta.url).resolve('@runno/wasi')))
+  return [fileURLToPath(new URL('../..', import.meta.url)), wasi, runtimeDir(), dirname(dirname(process.execPath))]
+}
+
+interface WasiMainResult {
+  durationMs: number
+  output?: WasiOutput
+  error?: string
+  timedOut?: boolean
+}
+
+/** Runs WASI programs at compile time, each in a child process whose thread runs the runtime. */
+export function createWasiExecutor(id: string, languages?: string[]): Executor {
+  return {
+    id,
+    supports: lang => runsLanguage(lang, languages),
+    fingerprint: runtimeFingerprint,
+    async run(request, signal, ctx): Promise<RunResult> {
+      if (signal?.aborted) return failedRun(id, 'The run was cancelled')
+      const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS
+      const job = {
+        request: { lang: request.lang, code: request.code, stdin: request.stdin, files: request.files, env: { ...ctx?.env } },
+        dir: runtimeDir(),
+        timeoutMs,
+        loadTimeoutMs: LOAD_TIMEOUT_MS,
+      }
+      const sandbox = ctx?.sandbox ?? directSandbox
+      let child
+      try {
+        child = await sandbox.run({ argv: [process.execPath, `--wasm-max-mem-pages=${MEMORY_LIMIT_MB * 16}`, MAIN, RUN_REQUEST_FILE, RESULT], files: { [RUN_REQUEST_FILE]: JSON.stringify(job) }, collect: [RESULT], env: {}, read: readable(), timeoutMs: LOAD_TIMEOUT_MS + timeoutMs + 10_000, signal })
+      } catch (error) {
+        return failedRun(id, `the ${sandbox.kind} sandbox failed: ${error instanceof Error ? error.message : String(error)}`)
+      }
+      if (signal?.aborted) return failedRun(id, 'The run was cancelled')
+      let result: WasiMainResult | undefined
+      try {
+        result = child.files[RESULT] ? JSON.parse(Buffer.from(child.files[RESULT]).toString('utf8')) as WasiMainResult : undefined
+      } catch {}
+      if (!result) return failedRun(id, child.stderr.trim() || `The WASI runtime ended (${child.exitCode}) before the run did`)
+      if (!result.output) return { ...failedRun(id, result.error ?? 'The WASI run failed', result.durationMs), ...result.timedOut ? { timedOut: true } : {} }
+      const { stdout, stderr, exitCode, outputs } = result.output
+      return { ok: exitCode === 0, stdout, stderr, exitCode, durationMs: result.durationMs, timedOut: false, source: 'live', executorId: id, outputs }
+    },
+  }
+}

package/src/node/presmium.ts

@@ -0,0 +1,35 @@
+import { createRequire } from 'node:module'
+import { environmentExecutor } from '@lincyaw/kernel'
+import type { EnvironmentProvider, PresmiumNodePlugin } from '@lincyaw/kernel'
+import { EXEC_WASI_ID, execWasiConfig, WASI_EXECUTOR_ID, WASI_KIND } from '../domain/index.ts'
+import { wasiLanguage } from '../shared/wasi-runner.mjs'
+import { createWasiExecutor } from './executor.ts'
+import { missingRuntime } from './runtime.ts'
+import { runtimesPass } from './runtimes.ts'
+import { wasiAssets } from './vite.ts'
+
+const { version } = createRequire(import.meta.url)('../../package.json') as { version: string }
+
+const languagesOf = (languages: string[] | undefined) => languages?.length ? languages : ['c', 'cpp', 'ruby', 'sql']
+
+const wasi: EnvironmentProvider = {
+  create(name, spec) {
+    return createWasiExecutor(environmentExecutor(name), spec.languages)
+  },
+  async probe(_name, spec) {
+    const problems = languagesOf(spec.languages).map(lang => wasiLanguage(lang) ? missingRuntime(lang) : `no WASI runtime runs ${lang}`)
+    return [...new Set(problems.filter(Boolean))].join('; ') || undefined
+  },
+}
+
+const plugin: PresmiumNodePlugin = {
+  id: EXEC_WASI_ID,
+  version,
+  kernel: '^1.0.0',
+  passes: [runtimesPass],
+  executors: [createWasiExecutor(WASI_EXECUTOR_ID)],
+  environments: { [WASI_KIND]: wasi },
+  assets: ({ config }) => [wasiAssets(execWasiConfig(config).runtimes)],
+}
+
+export default plugin

package/src/node/runtime.ts

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto'
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+import { RUNTIMES, runtimeOf } from '../shared/wasi-runner.mjs'
+
+const require = createRequire(import.meta.url)
+
+let found: string | undefined
+
+export function runtimeDir(): string {
+  if (found) return found
+  for (const modules of require.resolve.paths('@runno/sandbox') ?? []) {
+    const dir = join(modules, '@runno/sandbox/dist/langs')
+    if (existsSync(dir)) return found = dir
+  }
+  throw new Error('the WASI runtimes (@runno/sandbox) are not installed')
+}
+
+export function missingRuntime(lang: string): string | undefined {
+  const runtime = runtimeOf(lang)
+  if (!runtime) return `no WASI runtime runs ${lang}`
+  try {
+    const dir = runtimeDir()
+    const missing = RUNTIMES[runtime].filter(file => !existsSync(join(dir, file)))
+    return missing.length ? `missing runtime files: ${missing.join(', ')}` : undefined
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error)
+  }
+}
+
+const fingerprints = new Map<string, string>()
+
+export function runtimeFingerprint(lang: string): string {
+  const runtime = runtimeOf(lang)
+  if (!runtime) return ''
+  let fingerprint = fingerprints.get(runtime)
+  if (!fingerprint) {
+    const hash = createHash('sha256')
+    for (const file of RUNTIMES[runtime]) hash.update(readFileSync(join(runtimeDir(), file)))
+    fingerprint = `wasi ${runtime} sha256:${hash.digest('hex').slice(0, 16)}`
+    fingerprints.set(runtime, fingerprint)
+  }
+  return fingerprint
+}

package/src/node/runtimes.ts

@@ -0,0 +1,24 @@
+import { docBlocks, environmentExecutor, isRecord } from '@lincyaw/kernel'
+import type { IRPass } from '@lincyaw/kernel'
+import { EXEC_WASI_ID, WASI_EXECUTOR_ID, WASI_KIND } from '../domain/index.ts'
+import { runtimeOf } from '../shared/wasi-runner.mjs'
+
+/** Lists in the plugin's configuration the WASI runtimes that the page's live code needs, which the build then copies. */
+export const runtimesPass: IRPass = {
+  name: 'presmium.execWasi.runtimes',
+  run(doc) {
+    const environments = Object.entries(doc.config.execute?.environments ?? {})
+      .filter(([, spec]) => spec.kind === WASI_KIND)
+      .map(([name]) => environmentExecutor(name))
+    const runtimes = new Set<string>()
+    for (const { block: { node } } of docBlocks(doc)) {
+      if (node.type !== 'code' || !node.run || node.run.when === 'compile') continue
+      const { executor, lang } = node.run
+      if (executor && executor !== WASI_EXECUTOR_ID && !environments.includes(executor)) continue
+      const runtime = runtimeOf(lang)
+      if (runtime) runtimes.add(runtime)
+    }
+    const config = doc.config.presmium[EXEC_WASI_ID]
+    doc.config.presmium[EXEC_WASI_ID] = { ...isRecord(config) ? config : {}, runtimes: [...runtimes].sort() }
+  },
+}

package/src/node/vite.ts

@@ -0,0 +1,27 @@
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { RuntimeAssets } from '@lincyaw/kernel'
+import { RUNTIME_DIR } from '../domain/index.ts'
+import { RUNTIMES } from '../shared/wasi-runner.mjs'
+import type { Runtime } from '../shared/wasi-runner.mjs'
+import { runtimeDir } from './runtime.ts'
+
+const EXTENSION_TYPES: Record<string, string> = { '.wasm': 'application/wasm', '.gz': 'application/gzip' }
+const LICENSES = 'LICENSES'
+const LICENSES_FILE = fileURLToPath(new URL('../../LICENSES', import.meta.url))
+
+/** Every WASI runtime at `<base>wasi/`; a build copies those the deck's live code needs, with their licenses. */
+export function wasiAssets(runtimes: readonly string[]): RuntimeAssets {
+  const files = [...new Set(runtimes.flatMap(runtime => Object.hasOwn(RUNTIMES, runtime) ? RUNTIMES[runtime as Runtime] : []))]
+  const types = Object.fromEntries([
+    ...Object.values(RUNTIMES).flat().map(file => [file, EXTENSION_TYPES[file.slice(file.lastIndexOf('.'))] ?? 'application/octet-stream']),
+    [LICENSES, 'text/plain; charset=utf-8'],
+  ])
+  return {
+    name: 'presmium:wasi-runtime',
+    prefix: RUNTIME_DIR,
+    types,
+    emitted: files.length === 0 ? [] : [...files, LICENSES],
+    source: file => (file === LICENSES ? LICENSES_FILE : join(runtimeDir(), file)),
+  }
+}

package/src/node/wasi-main.mjs

@@ -0,0 +1,30 @@
+import { readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { Worker } from 'node:worker_threads'
+
+const [requestFile, resultFile] = process.argv.slice(2)
+const { request, dir, timeoutMs, loadTimeoutMs } = JSON.parse(readFileSync(requestFile, 'utf8'))
+const worker = new Worker(new URL('./wasi-thread.mjs', import.meta.url), { workerData: { request, dir }, env: {} })
+let started = 0
+const elapsed = () => (started ? Math.round(performance.now() - started) : 0)
+
+function finish(result) {
+  const part = resultFile.replace(/\.json$/, '.part')
+  writeFileSync(part, JSON.stringify({ durationMs: elapsed(), ...result }))
+  renameSync(part, resultFile)
+  process.exit(0)
+}
+
+let timer = setTimeout(() => finish({ error: `The WASI runtime did not load within ${loadTimeoutMs} ms` }), loadTimeoutMs)
+worker.on('message', (reply) => {
+  if (reply.type === 'started') {
+    clearTimeout(timer)
+    started = performance.now()
+    timer = setTimeout(() => finish({ error: `Stopped after ${timeoutMs} ms`, timedOut: true }), timeoutMs)
+  } else if (reply.type === 'done') {
+    finish({ output: reply.output })
+  } else {
+    finish({ error: `The WASI runtime failed: ${reply.error}` })
+  }
+})
+worker.on('error', error => finish({ error: `The WASI runtime failed: ${error.message}` }))
+worker.on('exit', code => finish({ error: `The WASI runtime ended (${code}) before the run did` }))

package/src/node/wasi-thread.mjs

@@ -0,0 +1,15 @@
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { parentPort, workerData } from 'node:worker_threads'
+import { prepare, runWasi } from '../shared/wasi-runner.mjs'
+
+const { request, dir } = workerData
+const load = name => readFile(join(dir, name))
+
+try {
+  await prepare(request.lang, load)
+  parentPort.postMessage({ type: 'started' })
+  parentPort.postMessage({ type: 'done', output: await runWasi(request, load) })
+} catch (error) {
+  parentPort.postMessage({ type: 'error', error: error instanceof Error ? error.message : String(error) })
+}

package/src/shared/wasi-runner.d.mts

@@ -0,0 +1,25 @@
+export interface WasiRequest {
+  lang: string
+  code: string
+  stdin?: string
+  files?: Record<string, string>
+  env?: Record<string, string>
+}
+
+export interface WasiOutput {
+  stdout: string
+  stderr: string
+  exitCode: number
+  outputs: { output_type: 'stream', name: 'stdout' | 'stderr', text: string }[]
+}
+
+export type RuntimeLoader = (file: string) => Promise<Uint8Array>
+
+export type Runtime = 'clang' | 'ruby' | 'sqlite'
+
+export const RUNTIMES: Record<Runtime, string[]>
+export function wasiLanguage(lang: string): 'c' | 'cpp' | 'ruby' | 'sql' | undefined
+export function runtimeOf(lang: string): Runtime | undefined
+export function runsLanguage(lang: string, languages?: string[]): boolean
+export function prepare(lang: string, load: RuntimeLoader): Promise<void>
+export function runWasi(request: WasiRequest, load: RuntimeLoader): Promise<WasiOutput>

package/src/shared/wasi-runner.mjs

@@ -0,0 +1,153 @@
+import { WASI } from '@runno/wasi'
+
+const SYSROOT = 'clang-fs.tar.gz'
+
+export const RUNTIMES = {
+  clang: ['clang.wasm', 'wasm-ld.wasm', SYSROOT],
+  ruby: ['ruby-3.2.0.wasm', 'ruby-3.2.0.tar.gz'],
+  sqlite: ['sqlite.wasm'],
+}
+
+const LANGUAGES = { 'c': 'c', 'cpp': 'cpp', 'c++': 'cpp', 'cc': 'cpp', 'cxx': 'cpp', 'ruby': 'ruby', 'rb': 'ruby', 'sql': 'sql', 'sqlite': 'sql' }
+const RUNTIME_OF = { c: 'clang', cpp: 'clang', ruby: 'ruby', sql: 'sqlite' }
+
+export function wasiLanguage(lang) {
+  const id = String(lang).trim().toLowerCase()
+  return Object.hasOwn(LANGUAGES, id) ? LANGUAGES[id] : undefined
+}
+
+export function runtimeOf(lang) {
+  const id = wasiLanguage(lang)
+  return id && RUNTIME_OF[id]
+}
+
+export function runsLanguage(lang, languages) {
+  const id = wasiLanguage(lang)
+  return id !== undefined && (!languages || languages.some(other => wasiLanguage(other) === id))
+}
+
+const EPOCH = new Date(0)
+const TIMES = { access: EPOCH, modification: EPOCH, change: EPOCH }
+const file = (path, content) => ({ path, timestamps: TIMES, ...typeof content === 'string' ? { mode: 'string', content } : { mode: 'binary', content } })
+
+const ready = new Map()
+
+function kept(name, make) {
+  if (!ready.has(name)) {
+    const value = make()
+    ready.set(name, value)
+    value.catch(() => ready.delete(name))
+  }
+  return ready.get(name)
+}
+
+const compiled = (name, load) => kept(name, () => load(name).then(bytes => WebAssembly.compile(bytes)))
+const unpacked = (name, load) => kept(name, () => load(name).then(untar))
+
+export async function prepare(lang, load) {
+  const runtime = runtimeOf(lang)
+  if (!runtime) throw new Error(`no WASI runtime runs ${lang}`)
+  await Promise.all(RUNTIMES[runtime].map(name => name.endsWith('.wasm') ? compiled(name, load) : unpacked(name, load)))
+}
+
+async function gunzip(bytes) {
+  if (bytes[0] !== 0x1F || bytes[1] !== 0x8B) return bytes
+  const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream('gzip'))
+  return new Uint8Array(await new Response(stream).arrayBuffer())
+}
+
+async function untar(gz) {
+  const tar = await gunzip(gz)
+  const text = new TextDecoder()
+  const field = (header, at, length) => text.decode(header.subarray(at, at + length)).replace(/\0.*$/s, '')
+  const fs = {}
+  for (let at = 0; at + 512 <= tar.length;) {
+    const header = tar.subarray(at, at + 512)
+    const name = field(header, 0, 100)
+    if (!name) break
+    const prefix = field(header, 345, 155)
+    const size = Number.parseInt(field(header, 124, 12).trim() || '0', 8)
+    const type = header[156]
+    if (type === 0x30 || type === 0) {
+      const path = `/${(prefix ? `${prefix}/${name}` : name).replace(/^\.?\//, '')}`
+      fs[path] = file(path, tar.slice(at + 512, at + 512 + size))
+    }
+    at += 512 + Math.ceil(size / 512) * 512
+  }
+  return fs
+}
+
+function reader(input) {
+  let rest = input
+  return (max) => {
+    if (!rest) return null
+    let n = Math.min(rest.length, Math.max(2, Math.floor(max / 3)))
+    const code = rest.charCodeAt(n - 1)
+    if (n < rest.length && code >= 0xD800 && code <= 0xDBFF) n--
+    const chunk = rest.slice(0, n)
+    rest = rest.slice(n)
+    return chunk
+  }
+}
+
+async function start(module, { args, env = {}, fs = {}, stdin = '', write }) {
+  const wasi = new WASI({
+    args,
+    env: { ...env },
+    fs,
+    stdin: reader(stdin),
+    stdout: text => write('stdout', text),
+    stderr: text => write('stderr', text),
+  })
+  const instance = await WebAssembly.instantiate(module, wasi.getImportObject())
+  try {
+    return wasi.start({ module, instance })
+  } catch (error) {
+    if (!(error instanceof WebAssembly.RuntimeError || error instanceof RangeError)) throw error
+    write('stderr', `${error.name}: ${error.message}\n`)
+    return { exitCode: 1, fs }
+  }
+}
+
+const CLANG_C = ['-cc1', '-Werror', '-triple', 'wasm32-unknown-wasi', '-isysroot', '/sys', '-internal-isystem', '/sys/include', '-internal-isystem', '/sys/lib/clang/8.0.1/include', '-ferror-limit', '4', '-fmessage-length', '80', '-O2', '-emit-obj']
+const CLANG_CPP = ['-cc1', '-Werror', '-emit-obj', '-disable-free', '-isysroot', '/sys', '-internal-isystem', '/sys/include/c++/v1', '-internal-isystem', '/sys/include', '-internal-isystem', '/sys/lib/clang/8.0.1/include', '-ferror-limit', '4', '-fmessage-length', '80', '-O2', '-x', 'c++']
+const LINK = ['--no-threads', '--export-dynamic', '-z', 'stack-size=1048576', '-L/sys/lib/wasm32-wasi', '/sys/lib/wasm32-wasi/crt1.o', '/program.o', '-lc']
+
+export async function runWasi(request, load) {
+  const lang = wasiLanguage(request.lang)
+  if (!lang) throw new Error(`no WASI runtime runs ${request.lang}`)
+  const streams = { stdout: '', stderr: '' }
+  const outputs = []
+  const write = (name, text) => {
+    if (!text) return
+    streams[name] += text
+    const last = outputs.at(-1)
+    if (last?.name === name) last.text += text
+    else outputs.push({ output_type: 'stream', name, text })
+  }
+  const files = {}
+  for (const [name, content] of Object.entries(request.files ?? {})) {
+    const path = `/${name.replace(/^\/+/, '')}`
+    files[path] = file(path, content)
+  }
+  const program = { fs: files, env: request.env, stdin: request.stdin ?? '', write }
+  const done = ({ exitCode }) => ({ ...streams, exitCode, outputs })
+
+  if (lang === 'ruby') {
+    const base = await unpacked('ruby-3.2.0.tar.gz', load)
+    return done(await start(await compiled('ruby-3.2.0.wasm', load), { ...program, args: ['ruby', '-r', '/ruby-3.2.0/.rubyopts.rb', '/program.rb'], fs: { ...base, ...files, '/program.rb': file('/program.rb', request.code) } }))
+  }
+  if (lang === 'sql') {
+    return done(await start(await compiled('sqlite.wasm', load), { ...program, args: ['sqlite', ':memory:', '.read /program.sql'], fs: { ...files, '/program.sql': file('/program.sql', request.code) } }))
+  }
+
+  const source = lang === 'cpp' ? '/program.cpp' : '/program.c'
+  const sysroot = await unpacked(SYSROOT, load)
+  const tool = { write, env: {}, stdin: '' }
+  const compile = await start(await compiled('clang.wasm', load), { ...tool, args: ['clang', ...lang === 'cpp' ? CLANG_CPP : CLANG_C, '-I', '/', '-o', '/program.o', source], fs: { ...sysroot, ...files, [source]: file(source, request.code) } })
+  if (compile.exitCode !== 0) return done(compile)
+  const link = await start(await compiled('wasm-ld.wasm', load), { ...tool, args: ['wasm-ld', ...LINK, ...lang === 'cpp' ? ['-lc++', '-lc++abi'] : [], '-o', '/program.wasm'], fs: { ...sysroot, '/program.o': compile.fs['/program.o'] } })
+  if (link.exitCode !== 0) return done(link)
+  const binary = link.fs['/program.wasm']
+  return done(await start(await WebAssembly.compile(binary.content), { ...program, args: ['program'] }))
+}