@bytecodealliance/jco 1.32.1 → 1.34.0

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

@@ -0,0 +1,35 @@
+package wasi:clocks@0.2.10;
+
+interface monotonic-clock {
+  use wasi:io/poll@0.2.10.{pollable};
+
+  type instant = u64;
+  type duration = u64;
+  now: func() -> instant;
+  resolution: func() -> duration;
+  subscribe-instant: func(when: instant) -> pollable;
+  subscribe-duration: func(when: duration) -> pollable;
+}
+
+interface wall-clock {
+  record datetime {
+    seconds: u64,
+    nanoseconds: u32,
+  }
+
+  now: func() -> datetime;
+  resolution: func() -> datetime;
+}
+
+interface timezone {
+  use wall-clock.{datetime};
+
+  record timezone-display {
+    utc-offset: s32,
+    name: string,
+    in-daylight-saving-time: bool,
+  }
+
+  display: func(when: datetime) -> timezone-display;
+  utc-offset: func(when: datetime) -> s32;
+}

package/lib/wit/builtin/0.2.10/wasi-io/package.wit

@@ -0,0 +1,47 @@
+package wasi:io@0.2.10;
+
+interface error {
+  resource error {
+    to-debug-string: func() -> string;
+  }
+}
+
+interface poll {
+  resource pollable {
+    ready: func() -> bool;
+    block: func();
+  }
+
+  poll: func(in: list<borrow<pollable>>) -> list<u32>;
+}
+
+interface streams {
+  use error.{error};
+  use poll.{pollable};
+
+  variant stream-error {
+    last-operation-failed(error),
+    closed,
+  }
+
+  resource input-stream {
+    read: func(len: u64) -> result<list<u8>, stream-error>;
+    blocking-read: func(len: u64) -> result<list<u8>, stream-error>;
+    skip: func(len: u64) -> result<u64, stream-error>;
+    blocking-skip: func(len: u64) -> result<u64, stream-error>;
+    subscribe: func() -> pollable;
+  }
+
+  resource output-stream {
+    check-write: func() -> result<u64, stream-error>;
+    write: func(contents: list<u8>) -> result<_, stream-error>;
+    blocking-write-and-flush: func(contents: list<u8>) -> result<_, stream-error>;
+    flush: func() -> result<_, stream-error>;
+    blocking-flush: func() -> result<_, stream-error>;
+    subscribe: func() -> pollable;
+    write-zeroes: func(len: u64) -> result<_, stream-error>;
+    blocking-write-zeroes-and-flush: func(len: u64) -> result<_, stream-error>;
+    splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>;
+    blocking-splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>;
+  }
+}

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

@@ -0,0 +1,168 @@
+package wasi:sockets@0.2.10;
+
+interface network {
+  use wasi:io/error@0.2.10.{error};
+
+  resource network {
+    /// Work around a ComponentizeJS 0.22 bindings bug: it omits the wrapper
+    /// class for a methodless resource when that resource crosses interfaces.
+    /// This method is deliberately never called and can be removed once the
+    /// bindings generator handles the canonical methodless WIT declaration.
+    noop: func();
+  }
+
+  enum error-code {
+    unknown,
+    access-denied,
+    not-supported,
+    invalid-argument,
+    out-of-memory,
+    timeout,
+    concurrency-conflict,
+    not-in-progress,
+    would-block,
+    invalid-state,
+    new-socket-limit,
+    address-not-bindable,
+    address-in-use,
+    remote-unreachable,
+    connection-refused,
+    connection-reset,
+    connection-aborted,
+    datagram-too-large,
+    name-unresolvable,
+    temporary-resolver-failure,
+    permanent-resolver-failure,
+  }
+
+  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) }
+  network-error-code: func(err: borrow<error>) -> option<error-code>;
+}
+
+interface instance-network {
+  use network.{network};
+  instance-network: func() -> network;
+}
+
+interface udp {
+  use wasi:io/poll@0.2.10.{pollable};
+  use network.{network, error-code, ip-socket-address, ip-address-family};
+
+  record incoming-datagram {
+    data: list<u8>,
+    remote-address: ip-socket-address,
+  }
+
+  record outgoing-datagram {
+    data: list<u8>,
+    remote-address: option<ip-socket-address>,
+  }
+
+  resource udp-socket {
+    start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
+    finish-bind: func() -> result<_, error-code>;
+    %stream: func(remote-address: option<ip-socket-address>) -> result<tuple<incoming-datagram-stream, outgoing-datagram-stream>, error-code>;
+    local-address: func() -> result<ip-socket-address, error-code>;
+    remote-address: func() -> result<ip-socket-address, error-code>;
+    address-family: func() -> ip-address-family;
+    unicast-hop-limit: func() -> result<u8, error-code>;
+    set-unicast-hop-limit: func(value: u8) -> result<_, error-code>;
+    receive-buffer-size: func() -> result<u64, error-code>;
+    set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+    send-buffer-size: func() -> result<u64, error-code>;
+    set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+    subscribe: func() -> pollable;
+  }
+
+  resource incoming-datagram-stream {
+    receive: func(max-results: u64) -> result<list<incoming-datagram>, error-code>;
+    subscribe: func() -> pollable;
+  }
+
+  resource outgoing-datagram-stream {
+    check-send: func() -> result<u64, error-code>;
+    send: func(datagrams: list<outgoing-datagram>) -> result<u64, error-code>;
+    subscribe: func() -> pollable;
+  }
+}
+
+interface udp-create-socket {
+  use network.{network, error-code, ip-address-family};
+  use udp.{udp-socket};
+  create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket, error-code>;
+}
+
+interface tcp {
+  use wasi:io/streams@0.2.10.{input-stream, output-stream};
+  use wasi:io/poll@0.2.10.{pollable};
+  use wasi:clocks/monotonic-clock@0.2.10.{duration};
+  use network.{network, error-code, ip-socket-address, ip-address-family};
+
+  enum shutdown-type { receive, send, both }
+
+  resource tcp-socket {
+    start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
+    finish-bind: func() -> result<_, error-code>;
+    start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>;
+    finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>;
+    start-listen: func() -> result<_, error-code>;
+    finish-listen: func() -> result<_, error-code>;
+    accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>;
+    local-address: func() -> result<ip-socket-address, error-code>;
+    remote-address: func() -> result<ip-socket-address, error-code>;
+    is-listening: func() -> bool;
+    address-family: func() -> ip-address-family;
+    set-listen-backlog-size: func(value: u64) -> result<_, error-code>;
+    keep-alive-enabled: func() -> result<bool, error-code>;
+    set-keep-alive-enabled: func(value: bool) -> result<_, error-code>;
+    keep-alive-idle-time: func() -> result<duration, error-code>;
+    set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>;
+    keep-alive-interval: func() -> result<duration, error-code>;
+    set-keep-alive-interval: func(value: duration) -> result<_, error-code>;
+    keep-alive-count: func() -> result<u32, error-code>;
+    set-keep-alive-count: func(value: u32) -> result<_, error-code>;
+    hop-limit: func() -> result<u8, error-code>;
+    set-hop-limit: func(value: u8) -> result<_, error-code>;
+    receive-buffer-size: func() -> result<u64, error-code>;
+    set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+    send-buffer-size: func() -> result<u64, error-code>;
+    set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+    subscribe: func() -> pollable;
+    shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>;
+  }
+}
+
+interface tcp-create-socket {
+  use network.{network, error-code, ip-address-family};
+  use tcp.{tcp-socket};
+  create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
+}
+
+interface ip-name-lookup {
+  use wasi:io/poll@0.2.10.{pollable};
+  use network.{network, error-code, ip-address};
+
+  resource resolve-address-stream {
+    resolve-next-address: func() -> result<option<ip-address>, error-code>;
+    subscribe: func() -> pollable;
+  }
+
+  resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream, error-code>;
+}

package/lib/wit/builtin/jco-node-0.1.0/child-process.wit

@@ -0,0 +1,42 @@
+package jco:node@0.1.0;
+
+interface child-process {
+  use types.{env-vars};
+
+  record process-error {
+    name: string,
+    message: string,
+    code: option<string>,
+    errno: option<s32>,
+    syscall: option<string>,
+    path: option<string>,
+    spawnargs: list<string>,
+  }
+
+  record spawn-options {
+    cwd: option<string>,
+    cwd-is-url: bool,
+    env: option<env-vars>,
+    input: option<list<u8>>,
+    timeout: u64,
+    kill-signal: string,
+    max-buffer: u64,
+    shell: option<string>,
+    stdio: option<list<string>>,
+    windows-hide: bool,
+    windows-verbatim-arguments: bool,
+    uid: option<u32>,
+    gid: option<u32>,
+  }
+
+  record spawn-output {
+    pid: option<u32>,
+    status: option<s32>,
+    signal: option<string>,
+    stdout: option<list<u8>>,
+    stderr: option<list<u8>>,
+    error: option<process-error>,
+  }
+
+  spawn-sync: func(command: string, args: list<string>, options: spawn-options) -> spawn-output;
+}

package/lib/wit/builtin/jco-node-0.1.0/cluster.wit

@@ -0,0 +1,112 @@
+package jco:node@0.1.0;
+
+/// Host-backed adapter for Node's `cluster` module.
+///
+/// WASI has no process model, so unlike Jco's other Node builtins this cannot be a portable
+/// shim. The host owns a real `node:cluster` and this interface exposes just enough of it to
+/// rebuild the observable JS surface guest-side.
+///
+/// Cluster is push-based and WIT is pull-based, so host events are queued and the guest drains
+/// them with `drain-events`. See
+/// `docs/src/interop/nodejs-builtins/supported-modules/cluster.md`
+/// for the delivery-timing difference this creates.
+interface cluster {
+    use types.{env-vars};
+
+    /// Lifecycle state of a worker, mirroring Node's `worker.state`.
+    enum worker-state {
+        none,
+        online,
+        listening,
+        disconnected,
+        dead,
+    }
+
+    /// Snapshot of a worker. `process` is deliberately absent: it is a `ChildProcess`, which
+    /// cannot cross this boundary. The guest surfaces an explicit error for it instead.
+    record worker-info {
+        id: u32,
+        state: worker-state,
+        exited-after-disconnect: bool,
+        connected: bool,
+        dead: bool,
+    }
+
+    /// How a worker exited. `signal` is empty when the worker exited normally.
+    record exit-info {
+        id: u32,
+        code: s32,
+        signal: string,
+    }
+
+    /// A message sent by a worker, carried as JSON because WIT has no dynamic value type.
+    record message-info {
+        id: u32,
+        json: string,
+    }
+
+    /// Settings the host applies to newly forked workers.
+    record settings {
+        silent: bool,
+        args: list<string>,
+        cwd: string,
+        scheduling-policy: u8,
+    }
+
+    /// An event the host observed since the last drain, in emission order.
+    variant event {
+        fork(u32),
+        online(u32),
+        disconnect(u32),
+        exit(exit-info),
+        message(message-info),
+        setup,
+    }
+
+    /// Why an operation the guest asked for cannot be carried out.
+    variant error {
+        /// The runtime has no process model at all (for example, a browser host).
+        unsupported(string),
+        /// No worker with this id is known.
+        no-such-worker(u32),
+        /// The host's cluster call failed.
+        failed(string),
+    }
+
+    /// Whether this instance is the cluster primary. False in a forked worker.
+    is-primary: func() -> bool;
+
+    /// The current worker's info, or none when running as the primary.
+    current-worker: func() -> option<worker-info>;
+
+    /// Fork a worker, re-executing the host entry so the component runs again as a worker.
+    fork: func(env: env-vars) -> result<worker-info, error>;
+
+    /// Every worker the host currently knows about.
+    list-workers: func() -> list<worker-info>;
+
+    /// Re-read one worker, so guest-side state can be refreshed after events.
+    get-worker: func(id: u32) -> result<worker-info, error>;
+
+    /// Send a JSON-encoded message to a worker, or to the primary when called from a worker.
+    send: func(id: u32, json: string) -> result<_, error>;
+
+    /// Disconnect one worker.
+    disconnect-worker: func(id: u32) -> result<_, error>;
+
+    /// Disconnect every worker.
+    disconnect-all: func() -> result<_, error>;
+
+    /// Signal a worker. An empty signal means the host default (`SIGTERM`).
+    kill: func(id: u32, signal: string) -> result<_, error>;
+
+    /// Read the settings the host will apply to new workers.
+    get-settings: func() -> settings;
+
+    /// Apply settings for subsequent forks. Fails for settings the host cannot honour, such as
+    /// `exec`, which is the host runner rather than a guest file.
+    set-settings: func(value: settings) -> result<_, error>;
+
+    /// Take every event queued since the last call, oldest first.
+    drain-events: func() -> list<event>;
+}

package/lib/wit/builtin/jco-node-0.1.0/console.wit

@@ -0,0 +1,12 @@
+package jco:node@0.1.0;
+
+interface console {
+  enum output-destination {
+    stdout,
+    stderr,
+  }
+
+  write: func(destination: output-destination, value: string);
+  is-terminal: func(destination: output-destination) -> bool;
+  color-depth: func(destination: output-destination) -> u8;
+}

package/lib/wit/builtin/jco-node-0.1.0/dgram.wit

@@ -0,0 +1,142 @@
+package jco:node@0.1.0;
+
+/// Explicit UDP capability. Guest-owned callbacks deliver DNS results, send
+/// completions and datagrams between component entry tasks. No Node objects,
+/// descriptors, or implicit networking authority cross this interface.
+interface dgram {
+    variant errno {
+        number(s64),
+        symbolic(string),
+    }
+
+    record buffer-error-info {
+        errno: f64,
+        code: string,
+        message: string,
+        syscall: string,
+    }
+
+    record error {
+        name: string,
+        message: string,
+        code: option<string>,
+        errno: option<errno>,
+        syscall: option<string>,
+        address: option<string>,
+        port: option<u16>,
+        info: option<buffer-error-info>,
+    }
+
+    enum socket-type {
+        udp4,
+        udp6,
+    }
+
+    record options {
+        %type: socket-type,
+        reuse-addr: bool,
+        reuse-port: bool,
+        ipv6-only: bool,
+    }
+
+    record address-info {
+        address: string,
+        family: string,
+        port: u16,
+    }
+
+    variant socket-option {
+        broadcast(bool),
+        multicast-loopback(bool),
+        ttl(f64),
+        multicast-ttl(f64),
+        recv-buffer(u32),
+        send-buffer(u32),
+        multicast-interface(string),
+    }
+
+    enum socket-query {
+        recv-buffer,
+        send-buffer,
+        send-queue-size,
+        send-queue-count,
+    }
+
+    enum membership-action {
+        add,
+        drop,
+        add-source,
+        drop-source,
+    }
+
+    create-socket: func(options: options, listener: u32) -> result<socket, error>;
+
+    resource socket {
+        /// Bind/connect only accept resolved addresses and complete synchronously.
+        bind: func(address: string, port: u16) -> result<address-info, error>;
+
+        connect: func(address: string, port: u16) -> result<_, error>;
+
+        disconnect: func() -> result<_, error>;
+
+        resolve: func(address: string, id: u32);
+
+        send: func(
+            data: list<u8>,
+            port: option<u16>,
+            address: option<string>,
+            callback: option<u32>,
+        ) -> result<_, error>;
+
+        address: func(remote: bool) -> result<address-info, error>;
+
+        set-option: func(%option: socket-option) -> result<_, error>;
+
+        query: func(query: socket-query) -> result<f64, error>;
+
+        membership: func(
+            action: membership-action,
+            group: string,
+            source: option<string>,
+            iface: option<string>,
+        ) -> result<_, error>;
+
+        close: func();
+
+        set-ref: func(%ref: bool);
+    }
+}
+
+/// Each component instance owns and redeems its listeners. Providers must serialize
+/// callback entry and drops, never re-enter while a guest import is on the stack.
+interface dgram-callbacks {
+    use dgram.{error, address-info};
+
+    record message {
+        data: list<u8>,
+        remote: address-info,
+    }
+
+    record resolved {
+        id: u32,
+        %result: result<string, error>,
+    }
+
+    record sent {
+        id: u32,
+        %result: result<u32, error>,
+    }
+
+    variant socket-event {
+        message(message),
+        error(error),
+        resolved(resolved),
+        sent(sent),
+    }
+
+    resource socket-listener {
+        event: func(event: socket-event);
+    }
+
+    take-socket-listener: func(id: u32) -> option<socket-listener>;
+}