@bytecodealliance/jco 1.32.0 → 1.33.0

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,111 @@
+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.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/dns.wit

@@ -0,0 +1,145 @@
+package jco:node@0.1.0;
+
+/// Typed, runtime-neutral host boundary for Node-compatible DNS operations.
+interface dns {
+  enum family {
+    unspecified,
+    ipv4,
+    ipv6,
+  }
+
+  enum result-order {
+    ipv4-first,
+    ipv6-first,
+    verbatim,
+  }
+
+  variant errno {
+    number(s64),
+    symbolic(string),
+  }
+
+  record error {
+    name: string,
+    message: string,
+    code: option<string>,
+    errno: option<errno>,
+    syscall: option<string>,
+    hostname: option<string>,
+  }
+
+  record resolver-options {
+    timeout: option<s32>,
+    tries: option<u32>,
+    max-timeout: option<u32>,
+  }
+
+  record resolver-config {
+    options: resolver-options,
+    servers: option<list<string>>,
+    local-address: option<tuple<string, string>>,
+  }
+
+  record lookup-options {
+    family: family,
+    hints: u32,
+    all: bool,
+    order: result-order,
+  }
+
+  record lookup-address {
+    address: string,
+    family: family,
+  }
+
+  record lookup-service-result {
+    hostname: string,
+    service: string,
+  }
+
+  record address-with-ttl {
+    address: string,
+    ttl: u32,
+  }
+
+  record caa-record {
+    critical: u32,
+    issue: option<string>,
+    issuewild: option<string>,
+    iodef: option<string>,
+    contactemail: option<string>,
+    contactphone: option<string>,
+  }
+
+  record mx-record {
+    priority: u32,
+    exchange: string,
+  }
+
+  record naptr-record {
+    %flags: string,
+    service: string,
+    regexp: string,
+    replacement: string,
+    order: u32,
+    preference: u32,
+  }
+
+  record soa-record {
+    nsname: string,
+    hostmaster: string,
+    serial: u32,
+    refresh: u32,
+    retry: u32,
+    expire: u32,
+    minttl: u32,
+  }
+
+  record srv-record {
+    priority: u32,
+    weight: u32,
+    port: u16,
+    name: string,
+  }
+
+  record tlsa-record {
+    cert-usage: u8,
+    selector: u8,
+    match: u8,
+    data: list<u8>,
+  }
+
+  variant any-record {
+    a(address-with-ttl),
+    aaaa(address-with-ttl),
+    caa(caa-record),
+    cname(string),
+    mx(mx-record),
+    naptr(naptr-record),
+    ns(string),
+    ptr(string),
+    soa(soa-record),
+    srv(srv-record),
+    tlsa(tlsa-record),
+    txt(list<string>),
+  }
+
+  get-servers: func() -> result<list<string>, error>;
+  validate-servers: func(servers: list<string>) -> result<list<string>, error>;
+  lookup: func(hostname: string, options: lookup-options) -> result<list<lookup-address>, error>;
+  lookup-service: func(address: string, port: u16) -> result<lookup-service-result, error>;
+  resolve4: func(hostname: string, ttl: bool, resolver: option<resolver-config>) -> result<list<address-with-ttl>, error>;
+  resolve6: func(hostname: string, ttl: bool, resolver: option<resolver-config>) -> result<list<address-with-ttl>, error>;
+  resolve-any: func(hostname: string, resolver: option<resolver-config>) -> result<list<any-record>, error>;
+  resolve-caa: func(hostname: string, resolver: option<resolver-config>) -> result<list<caa-record>, error>;
+  resolve-cname: func(hostname: string, resolver: option<resolver-config>) -> result<list<string>, error>;
+  resolve-mx: func(hostname: string, resolver: option<resolver-config>) -> result<list<mx-record>, error>;
+  resolve-naptr: func(hostname: string, resolver: option<resolver-config>) -> result<list<naptr-record>, error>;
+  resolve-ns: func(hostname: string, resolver: option<resolver-config>) -> result<list<string>, error>;
+  resolve-ptr: func(hostname: string, resolver: option<resolver-config>) -> result<list<string>, error>;
+  resolve-soa: func(hostname: string, resolver: option<resolver-config>) -> result<soa-record, error>;
+  resolve-srv: func(hostname: string, resolver: option<resolver-config>) -> result<list<srv-record>, error>;
+  resolve-tlsa: func(hostname: string, resolver: option<resolver-config>) -> result<list<tlsa-record>, error>;
+  resolve-txt: func(hostname: string, resolver: option<resolver-config>) -> result<list<list<string>>, error>;
+  reverse: func(ip: string, resolver: option<resolver-config>) -> result<list<string>, error>;
+}

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

@@ -0,0 +1,116 @@
+package jco:node@0.1.0;
+
+/// Host-backed adapter for Node's `ffi` module.
+///
+/// `node:ffi` arrived in Node 26.1.0 (Stability 1, behind `--experimental-ffi`), so unlike the
+/// other Node builtins this one has no Node 24 equivalent at all. WASI has nothing like it: there
+/// is no dynamic loader and no host address space to reach. The host owns a real `node:ffi` and
+/// this interface exposes enough of it to rebuild the observable JS surface guest-side.
+///
+/// Pointers cross as `u64` and become JavaScript `bigint`s, matching what Node hands back.
+///
+/// Parts of Node's surface deliberately have no representation here, because a component cannot
+/// express them and a silently wrong answer would be worse than an error. Each is refused
+/// guest-side; see the matching `TODO(ffi)` in jco-std for what lifting it would take.
+///
+/// - **Guest memory has no host address.** `ffi.getRawPointer()` asks for the address of a
+///   JavaScript buffer; guest memory is not mapped into the host, so the guest refuses instead.
+/// - **The host cannot call back into the guest.** `register-callback` would need a `callback`
+///   resource for the trampoline's lifetime *and* a guest export for the host to invoke when
+///   native code fires. Resources alone would not do it: their methods run host-side.
+/// - **Buffer-shaped arguments** would be copied, so a native function writing through the pointer
+///   writes into a copy the guest never sees. Callers pass a `pointer` and use
+///   `read-bytes`/`write-bytes`, which is explicit about the copy. Adding copy-out results to
+///   `call` would make out-parameters work.
+///
+/// The library handle is a `u32` rather than a `resource`, matching `cluster`'s worker ids, which
+/// is the shape componentize-js is known to handle. A resource would give it a drop and remove the
+/// stale-handle case; worth revisiting when guest-side resource support is proven.
+interface ffi {
+    /// A value crossing the boundary, tagged by the type it was declared as.
+    ///
+    /// `nothing` is Node's `void`. There is no buffer case on purpose -- see the interface docs.
+    variant value {
+        nothing,
+        boolean(bool),
+        int8(s8),
+        uint8(u8),
+        int16(s16),
+        uint16(u16),
+        int32(s32),
+        uint32(u32),
+        int64(s64),
+        uint64(u64),
+        float32(f32),
+        float64(f64),
+        pointer(u64),
+        text(string),
+    }
+
+    /// A failure reported by the host's `node:ffi`, carrying Node's own code where it has one.
+    record failure {
+        code: string,
+        message: string,
+    }
+
+    variant error {
+        /// No FFI capability was granted to this component.
+        denied(string),
+        /// The host runtime has no `node:ffi`: it predates Node 26.1.0, or the flag is missing.
+        unavailable(string),
+        /// The library handle is not open.
+        no-such-library(u32),
+        /// The symbol has not been defined on that library.
+        no-such-symbol(string),
+        /// The signature names a type this boundary cannot carry.
+        unsupported-type(string),
+        /// The underlying call failed.
+        failed(failure),
+    }
+
+    /// A function signature. Type names are Node's own: `int32`, `pointer`, `string`, `void`, ...
+    record signature {
+        arguments: list<string>,
+        returns: string,
+    }
+
+    /// The host platform's shared-library suffix: `so`, `dylib`, or `dll`.
+    suffix: func() -> string;
+
+    /// Load a shared library. A missing path resolves symbols from the host process image.
+    open: func(path: option<string>) -> result<u32, error>;
+
+    /// Release a library handle.
+    close: func(handle: u32) -> result<_, error>;
+
+    /// Resolve a symbol's address.
+    symbol: func(handle: u32, name: string) -> result<u64, error>;
+
+    /// Declare a function so it can be called. Separate from `call` so a signature is validated
+    /// once, where Node validates it, rather than on every invocation.
+    define: func(handle: u32, name: string, sig: signature) -> result<_, error>;
+
+    /// Call a previously declared function.
+    call: func(handle: u32, name: string, args: list<value>) -> result<value, error>;
+
+    /// Read one primitive from host memory. `kind` is a Node type name.
+    read: func(pointer: u64, offset: u64, kind: string) -> result<value, error>;
+
+    /// Write one primitive into host memory.
+    write: func(pointer: u64, offset: u64, kind: string, data: value) -> result<_, error>;
+
+    /// Read a NUL-terminated string. Absent for a null pointer, which is what Node returns.
+    read-text: func(pointer: u64) -> result<option<string>, error>;
+
+    /// Copy bytes out of host memory. Always a copy: a component cannot hold a live view.
+    read-bytes: func(pointer: u64, length: u64) -> result<list<u8>, error>;
+
+    /// Copy bytes into host memory.
+    write-bytes: func(pointer: u64, length: u64, data: list<u8>) -> result<_, error>;
+
+    /// Encode a string into host memory.
+    write-text: func(pointer: u64, length: u64, data: string, encoding: string) -> result<_, error>;
+
+    /// The host's libuv event loop address.
+    current-event-loop: func() -> result<u64, error>;
+}