@bytecodealliance/jco 1.30.0 → 1.32.0

package/lib/wit/builtin/0.3.0/wasi-cli/package.wit

@@ -0,0 +1,70 @@
+package wasi:cli@0.3.0;
+world command {
+  include imports;
+  export run;
+}
+interface environment {
+  get-environment: func() -> list<tuple<string, string>>;
+  get-arguments: func() -> list<string>;
+  get-initial-cwd: func() -> option<string>;
+}
+interface exit {
+  exit: func(status: result);
+  exit-with-code: func(status-code: u8);
+}
+world imports {
+  include wasi:clocks/imports@0.3.0;
+  include wasi:filesystem/imports@0.3.0;
+  include wasi:sockets/imports@0.3.0;
+  include wasi:random/imports@0.3.0;
+  import environment;
+  import exit;
+  import stdin;
+  import stdout;
+  import stderr;
+  import terminal-input;
+  import terminal-output;
+  import terminal-stdin;
+  import terminal-stdout;
+  import terminal-stderr;
+}
+interface run {
+  run: async func() -> result;
+}
+interface types {
+  enum error-code {
+    io,
+    illegal-byte-sequence,
+    pipe,
+  }
+}
+interface stdin {
+  use types.{error-code};
+  read-via-stream: func() -> tuple<stream<u8>, future<result<_, error-code>>>;
+}
+interface stdout {
+  use types.{error-code};
+  write-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+}
+interface stderr {
+  use types.{error-code};
+  write-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+}
+interface terminal-input {
+    resource terminal-input;
+}
+interface terminal-output {
+    resource terminal-output;
+}
+interface terminal-stdin {
+    use terminal-input.{terminal-input};
+    get-terminal-stdin: func() -> option<terminal-input>;
+}
+interface terminal-stdout {
+    use terminal-output.{terminal-output};
+    get-terminal-stdout: func() -> option<terminal-output>;
+}
+interface terminal-stderr {
+    use terminal-output.{terminal-output};
+    get-terminal-stderr: func() -> option<terminal-output>;
+}

package/lib/wit/builtin/0.3.0/wasi-clocks/package.wit

@@ -0,0 +1,42 @@
+package wasi:clocks@0.3.0;
+interface monotonic-clock {
+    use types.{duration};
+    type mark = u64;
+    now: func() -> mark;
+    get-resolution: func() -> duration;
+    wait-until: async func(
+        when: mark,
+    );
+    wait-for: async func(
+        how-long: duration,
+    );
+}
+interface system-clock {
+    use types.{duration};
+    record instant {
+        seconds: s64,
+        nanoseconds: u32,
+    }
+    now: func() -> instant;
+    get-resolution: func() -> duration;
+}
+@unstable(feature = clocks-timezone)
+interface timezone {
+    @unstable(feature = clocks-timezone)
+    use system-clock.{instant};
+    @unstable(feature = clocks-timezone)
+    iana-id: func() -> option<string>;
+    @unstable(feature = clocks-timezone)
+    utc-offset: func(when: instant) -> option<s64>;
+    @unstable(feature = clocks-timezone)
+    to-debug-string: func() -> string;
+}
+interface types {
+    type duration = u64;
+}
+world imports {
+    import monotonic-clock;
+    import system-clock;
+    @unstable(feature = clocks-timezone)
+    import timezone;
+}

package/lib/wit/builtin/0.3.0/wasi-filesystem/package.wit

@@ -0,0 +1,184 @@
+package wasi:filesystem@0.3.0;
+interface preopens {
+    use types.{descriptor};
+    get-directories: func() -> list<tuple<descriptor, string>>;
+}
+interface types {
+    use wasi:clocks/system-clock@0.3.0.{instant};
+    type filesize = u64;
+    variant descriptor-type {
+        block-device,
+        character-device,
+        directory,
+        fifo,
+        symbolic-link,
+        regular-file,
+        socket,
+        other(option<string>),
+    }
+    flags descriptor-flags {
+        read,
+        write,
+        file-integrity-sync,
+        data-integrity-sync,
+        requested-write-sync,
+        mutate-directory,
+    }
+    record descriptor-stat {
+        %type: descriptor-type,
+        link-count: link-count,
+        size: filesize,
+        data-access-timestamp: option<instant>,
+        data-modification-timestamp: option<instant>,
+        status-change-timestamp: option<instant>,
+    }
+    flags path-flags {
+        symlink-follow,
+    }
+    flags open-flags {
+        create,
+        directory,
+        exclusive,
+        truncate,
+    }
+    type link-count = u64;
+    variant new-timestamp {
+        no-change,
+        now,
+        timestamp(instant),
+    }
+    record directory-entry {
+        %type: descriptor-type,
+        name: string,
+    }
+    variant error-code {
+        access,
+        already,
+        bad-descriptor,
+        busy,
+        deadlock,
+        quota,
+        exist,
+        file-too-large,
+        illegal-byte-sequence,
+        in-progress,
+        interrupted,
+        invalid,
+        io,
+        is-directory,
+        loop,
+        too-many-links,
+        message-size,
+        name-too-long,
+        no-device,
+        no-entry,
+        no-lock,
+        insufficient-memory,
+        insufficient-space,
+        not-directory,
+        not-empty,
+        not-recoverable,
+        unsupported,
+        no-tty,
+        no-such-device,
+        overflow,
+        not-permitted,
+        pipe,
+        read-only,
+        invalid-seek,
+        text-file-busy,
+        cross-device,
+        other(option<string>),
+    }
+    enum advice {
+        normal,
+        sequential,
+        random,
+        will-need,
+        dont-need,
+        no-reuse,
+    }
+    record metadata-hash-value {
+       lower: u64,
+       upper: u64,
+    }
+    resource descriptor {
+        read-via-stream: func(
+            offset: filesize,
+        ) -> tuple<stream<u8>, future<result<_, error-code>>>;
+        write-via-stream: func(
+            data: stream<u8>,
+            offset: filesize,
+        ) -> future<result<_, error-code>>;
+        append-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+        advise: async func(
+            offset: filesize,
+            length: filesize,
+            advice: advice
+        ) -> result<_, error-code>;
+        sync-data: async func() -> result<_, error-code>;
+        get-flags: async func() -> result<descriptor-flags, error-code>;
+        get-type: async func() -> result<descriptor-type, error-code>;
+        set-size: async func(size: filesize) -> result<_, error-code>;
+        set-times: async func(
+            data-access-timestamp: new-timestamp,
+            data-modification-timestamp: new-timestamp,
+        ) -> result<_, error-code>;
+        read-directory: func() -> tuple<stream<directory-entry>, future<result<_, error-code>>>;
+        sync: async func() -> result<_, error-code>;
+        create-directory-at: async func(
+            path: string,
+        ) -> result<_, error-code>;
+        stat: async func() -> result<descriptor-stat, error-code>;
+        stat-at: async func(
+            path-flags: path-flags,
+            path: string,
+        ) -> result<descriptor-stat, error-code>;
+        set-times-at: async func(
+            path-flags: path-flags,
+            path: string,
+            data-access-timestamp: new-timestamp,
+            data-modification-timestamp: new-timestamp,
+        ) -> result<_, error-code>;
+        link-at: async func(
+            old-path-flags: path-flags,
+            old-path: string,
+            new-descriptor: borrow<descriptor>,
+            new-path: string,
+        ) -> result<_, error-code>;
+        open-at: async func(
+            path-flags: path-flags,
+            path: string,
+            open-flags: open-flags,
+            %flags: descriptor-flags,
+        ) -> result<descriptor, error-code>;
+        readlink-at: async func(
+            path: string,
+        ) -> result<string, error-code>;
+        remove-directory-at: async func(
+            path: string,
+        ) -> result<_, error-code>;
+        rename-at: async func(
+            old-path: string,
+            new-descriptor: borrow<descriptor>,
+            new-path: string,
+        ) -> result<_, error-code>;
+        symlink-at: async func(
+            old-path: string,
+            new-path: string,
+        ) -> result<_, error-code>;
+        unlink-file-at: async func(
+            path: string,
+        ) -> result<_, error-code>;
+        is-same-object: async func(other: borrow<descriptor>) -> bool;
+        metadata-hash: async func() -> result<metadata-hash-value, error-code>;
+        metadata-hash-at: async func(
+            path-flags: path-flags,
+            path: string,
+        ) -> result<metadata-hash-value, error-code>;
+    }
+}
+world imports {
+    import types;
+    import preopens;
+}

package/lib/wit/builtin/0.3.0/wasi-http/package.wit

@@ -0,0 +1,170 @@
+package wasi:http@0.3.0;
+interface types {
+  use wasi:clocks/types@0.3.0.{duration};
+  variant method {
+    get,
+    head,
+    post,
+    put,
+    delete,
+    connect,
+    options,
+    trace,
+    patch,
+    other(string)
+  }
+  variant scheme {
+    HTTP,
+    HTTPS,
+    other(string)
+  }
+  variant error-code {
+    DNS-timeout,
+    DNS-error(DNS-error-payload),
+    destination-not-found,
+    destination-unavailable,
+    destination-IP-prohibited,
+    destination-IP-unroutable,
+    connection-refused,
+    connection-terminated,
+    connection-timeout,
+    connection-read-timeout,
+    connection-write-timeout,
+    connection-limit-reached,
+    TLS-protocol-error,
+    TLS-certificate-error,
+    TLS-alert-received(TLS-alert-received-payload),
+    HTTP-request-denied,
+    HTTP-request-length-required,
+    HTTP-request-body-size(option<u64>),
+    HTTP-request-method-invalid,
+    HTTP-request-URI-invalid,
+    HTTP-request-URI-too-long,
+    HTTP-request-header-section-size(option<u32>),
+    HTTP-request-header-size(option<field-size-payload>),
+    HTTP-request-trailer-section-size(option<u32>),
+    HTTP-request-trailer-size(field-size-payload),
+    HTTP-response-incomplete,
+    HTTP-response-header-section-size(option<u32>),
+    HTTP-response-header-size(field-size-payload),
+    HTTP-response-body-size(option<u64>),
+    HTTP-response-trailer-section-size(option<u32>),
+    HTTP-response-trailer-size(field-size-payload),
+    HTTP-response-transfer-coding(option<string>),
+    HTTP-response-content-coding(option<string>),
+    HTTP-response-timeout,
+    HTTP-upgrade-failed,
+    HTTP-protocol-error,
+    loop-detected,
+    configuration-error,
+    internal-error(option<string>)
+  }
+  record DNS-error-payload {
+    rcode: option<string>,
+    info-code: option<u16>
+  }
+  record TLS-alert-received-payload {
+    alert-id: option<u8>,
+    alert-message: option<string>
+  }
+  record field-size-payload {
+    field-name: option<string>,
+    field-size: option<u32>
+  }
+  variant header-error {
+    invalid-syntax,
+    forbidden,
+    immutable,
+    size-exceeded,
+    other(option<string>),
+  }
+  variant request-options-error {
+    not-supported,
+    immutable,
+    other(option<string>),
+  }
+  type field-name = string;
+  type field-value = list<u8>;
+  resource fields {
+    constructor();
+    from-list: static func(
+      entries: list<tuple<field-name,field-value>>
+    ) -> result<fields, header-error>;
+    get: func(name: field-name) -> list<field-value>;
+    has: func(name: field-name) -> bool;
+    set: func(name: field-name, value: list<field-value>) -> result<_, header-error>;
+    delete: func(name: field-name) -> result<_, header-error>;
+    get-and-delete: func(name: field-name) -> result<list<field-value>, header-error>;
+    append: func(name: field-name, value: field-value) -> result<_, header-error>;
+    copy-all: func() -> list<tuple<field-name,field-value>>;
+    clone: func() -> fields;
+  }
+  type headers = fields;
+  type trailers = fields;
+  resource request {
+    new: static func(
+      headers: headers,
+      contents: option<stream<u8>>,
+      trailers: future<result<option<trailers>, error-code>>,
+      options: option<request-options>
+    ) -> tuple<request, future<result<_, error-code>>>;
+    get-method: func() -> method;
+    set-method: func(method: method) -> result;
+    get-path-with-query: func() -> option<string>;
+    set-path-with-query: func(path-with-query: option<string>) -> result;
+    get-scheme: func() -> option<scheme>;
+    set-scheme: func(scheme: option<scheme>) -> result;
+    get-authority: func() -> option<string>;
+    set-authority: func(authority: option<string>) -> result;
+    get-options: func() -> option<request-options>;
+    get-headers: func() -> headers;
+    consume-body: static func(this: request, res: future<result<_, error-code>>) -> tuple<stream<u8>, future<result<option<trailers>, error-code>>>;
+  }
+  resource request-options {
+    constructor();
+    get-connect-timeout: func() -> option<duration>;
+    set-connect-timeout: func(duration: option<duration>) -> result<_, request-options-error>;
+    get-first-byte-timeout: func() -> option<duration>;
+    set-first-byte-timeout: func(duration: option<duration>) -> result<_, request-options-error>;
+    get-between-bytes-timeout: func() -> option<duration>;
+    set-between-bytes-timeout: func(duration: option<duration>) -> result<_, request-options-error>;
+    clone: func() -> request-options;
+  }
+  type status-code = u16;
+  resource response {
+    new: static func(
+      headers: headers,
+      contents: option<stream<u8>>,
+      trailers: future<result<option<trailers>, error-code>>,
+    ) -> tuple<response, future<result<_, error-code>>>;
+    get-status-code: func() -> status-code;
+    set-status-code: func(status-code: status-code) -> result;
+    get-headers: func() -> headers;
+    consume-body: static func(this: response, res: future<result<_, error-code>>) -> tuple<stream<u8>, future<result<option<trailers>, error-code>>>;
+  }
+}
+world service {
+  include wasi:clocks/imports@0.3.0;
+  include wasi:random/imports@0.3.0;
+  import wasi:cli/stdout@0.3.0;
+  import wasi:cli/stderr@0.3.0;
+  import wasi:cli/stdin@0.3.0;
+  import client;
+  export handler;
+}
+world middleware {
+  include service;
+  import handler;
+}
+interface handler {
+  use types.{request, response, error-code};
+  handle: async func(
+    request: request,
+  ) -> result<response, error-code>;
+}
+interface client {
+  use types.{request, response, error-code};
+  send: async func(
+    request: request,
+  ) -> result<response, error-code>;
+}

package/lib/wit/builtin/0.3.0/wasi-random/package.wit

@@ -0,0 +1,17 @@
+package wasi:random@0.3.0;
+interface insecure-seed {
+    get-insecure-seed: func() -> tuple<u64, u64>;
+}
+interface insecure {
+    get-insecure-random-bytes: func(max-len: u64) -> list<u8>;
+    get-insecure-random-u64: func() -> u64;
+}
+interface random {
+    get-random-bytes: func(max-len: u64) -> list<u8>;
+    get-random-u64: func() -> u64;
+}
+world imports {
+    import random;
+    import insecure;
+    import insecure-seed;
+}

package/lib/wit/builtin/0.3.0/wasi-sockets/package.wit

@@ -0,0 +1,105 @@
+package wasi:sockets@0.3.0;
+interface ip-name-lookup {
+    use types.{ip-address};
+    variant error-code {
+        access-denied,
+        invalid-argument,
+        name-unresolvable,
+        temporary-resolver-failure,
+        permanent-resolver-failure,
+        other(option<string>),
+    }
+    resolve-addresses: async func(name: string) -> result<list<ip-address>, error-code>;
+}
+interface types {
+    use wasi:clocks/types@0.3.0.{duration};
+    variant error-code {
+        access-denied,
+        not-supported,
+        invalid-argument,
+        out-of-memory,
+        timeout,
+        invalid-state,
+        address-not-bindable,
+        address-in-use,
+        remote-unreachable,
+        connection-refused,
+        connection-broken,
+        connection-reset,
+        connection-aborted,
+        datagram-too-large,
+        other(option<string>),
+    }
+    enum ip-address-family {
+        ipv4,
+        ipv6,
+    }
+    type ipv4-address = tuple<u8, u8, u8, u8>;
+    type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;
+    variant ip-address {
+        ipv4(ipv4-address),
+        ipv6(ipv6-address),
+    }
+    record ipv4-socket-address {
+        port: u16,
+        address: ipv4-address,
+    }
+    record ipv6-socket-address {
+        port: u16,
+        flow-info: u32,
+        address: ipv6-address,
+        scope-id: u32,
+    }
+    variant ip-socket-address {
+        ipv4(ipv4-socket-address),
+        ipv6(ipv6-socket-address),
+    }
+    resource tcp-socket {
+        create: static func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
+        bind: func(local-address: ip-socket-address) -> result<_, error-code>;
+        connect: async func(remote-address: ip-socket-address) -> result<_, error-code>;
+        listen: func() -> result<stream<tcp-socket>, error-code>;
+        send: func(data: stream<u8>) -> future<result<_, error-code>>;
+        receive: func() -> tuple<stream<u8>, future<result<_, error-code>>>;
+        get-local-address: func() -> result<ip-socket-address, error-code>;
+        get-remote-address: func() -> result<ip-socket-address, error-code>;
+        get-is-listening: func() -> bool;
+        get-address-family: func() -> ip-address-family;
+        set-listen-backlog-size: func(value: u64) -> result<_, error-code>;
+        get-keep-alive-enabled: func() -> result<bool, error-code>;
+        set-keep-alive-enabled: func(value: bool) -> result<_, error-code>;
+        get-keep-alive-idle-time: func() -> result<duration, error-code>;
+        set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>;
+        get-keep-alive-interval: func() -> result<duration, error-code>;
+        set-keep-alive-interval: func(value: duration) -> result<_, error-code>;
+        get-keep-alive-count: func() -> result<u32, error-code>;
+        set-keep-alive-count: func(value: u32) -> result<_, error-code>;
+        get-hop-limit: func() -> result<u8, error-code>;
+        set-hop-limit: func(value: u8) -> result<_, error-code>;
+        get-receive-buffer-size: func() -> result<u64, error-code>;
+        set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+        get-send-buffer-size: func() -> result<u64, error-code>;
+        set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+    }
+    resource udp-socket {
+        create: static func(address-family: ip-address-family) -> result<udp-socket, error-code>;
+        bind: func(local-address: ip-socket-address) -> result<_, error-code>;
+        connect: func(remote-address: ip-socket-address) -> result<_, error-code>;
+        disconnect: func() -> result<_, error-code>;
+        send: async func(data: list<u8>, remote-address: option<ip-socket-address>) -> result<_, error-code>;
+        receive: async func() -> result<tuple<list<u8>, ip-socket-address>, error-code>;
+        get-local-address: func() -> result<ip-socket-address, error-code>;
+        get-remote-address: func() -> result<ip-socket-address, error-code>;
+        get-address-family: func() -> ip-address-family;
+        get-unicast-hop-limit: func() -> result<u8, error-code>;
+        set-unicast-hop-limit: func(value: u8) -> result<_, error-code>;
+        get-receive-buffer-size: func() -> result<u64, error-code>;
+        set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+        get-send-buffer-size: func() -> result<u64, error-code>;
+        set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+    }
+}
+world imports {
+    import types;
+    import ip-name-lookup;
+}

package/lib/wit/builtin/LICENSE.md

@@ -0,0 +1,8 @@
+Copyright © 2019-2023 the Contributors to the WASI Specification, published
+by the [WebAssembly Community Group][cg] under the
+[W3C Community Contributor License Agreement (CLA)][cla]. A human-readable
+[summary][summary] is available.
+
+[cg]: https://www.w3.org/community/webassembly/
+[cla]: https://www.w3.org/community/about/agreements/cla/
+[summary]: https://www.w3.org/community/about/agreements/cla-deed/

package/lib/wit/builtin/README.md

@@ -0,0 +1,12 @@
+# Bundled WASI WIT snapshots
+
+These WIT sources are derived from the official
+[`WebAssembly/WASI`](https://github.com/WebAssembly/WASI) repository:
+
+- `0.3.0`: tag `v0.3.0`, commit `3ee2a590c766594ae44a54730fc74fc27da5c609`
+- `0.2.12`: tag `v0.2.12`, commit `281ba75fafcd50961ef55f9e52747afcc9b71ede`
+
+Each proposal package's `.wit` files are combined into one `package.wit`.
+Documentation comments, blank lines, and release-history annotations are
+removed to reduce the published package size; WIT declarations are unchanged.
+The snapshots remain covered by the official WASI license in `LICENSE.md`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/jco",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "JavaScript tooling for working with WebAssembly Components",
   "keywords": [
     "Component",
@@ -57,9 +57,8 @@
   "dependencies": {
     "@bytecodealliance/componentize-js": "^0.22.0",
     "@bytecodealliance/componentize-js-0-19-3": "npm:@bytecodealliance/componentize-js@^0.19.3",
-    "@bytecodealliance/jco-transpile": "^0.10.0",
-    "@bytecodealliance/preview2-shim": "^0.20.2",
-    "@bytecodealliance/preview3-shim": "^0.3.2",
+    "@bytecodealliance/jco-transpile": "^0.12.0",
+    "@bytecodealliance/preview2-shim": "^0.22.0",
     "binaryen": "^130.0.0",
     "commander": "^14",
     "componentize-qjs": "^0.4.2",
@@ -88,6 +87,7 @@
     "build:ts": "tsc -p tsconfig.json",
     "build:types:preview2-shim": "pnpm run build:types:preview2-shim --include-workspace-root",
     "build:test:components": "cargo xtask build-test-components",
+    "bench:serve-isolation": "node test/bench/serve-request-isolation.js",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
     "lint": "oxlint",