@bytecodealliance/jco 1.32.1 → 1.34.0

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>;
+}

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

@@ -0,0 +1,208 @@
+package jco:node@0.1.0;
+
+/// Typed, runtime-neutral host boundary for the supported Node filesystem API.
+interface fs {
+  variant path {
+    text(string),
+    bytes(list<u8>),
+    file-url(string),
+  }
+
+  variant path-or-descriptor {
+    path(path),
+    descriptor(u32),
+  }
+
+  variant mode {
+    number(u32),
+    symbolic(string),
+  }
+
+  variant open-mode {
+    number(s32),
+    symbolic(string),
+  }
+
+  variant errno {
+    number(s64),
+    symbolic(string),
+  }
+
+  record error {
+    name: string,
+    message: string,
+    code: option<string>,
+    errno: option<errno>,
+    syscall: option<string>,
+    path: option<string>,
+    dest: option<string>,
+  }
+
+  enum file-type {
+    block,
+    character,
+    directory,
+    fifo,
+    file,
+    socket,
+    symlink,
+    unknown,
+  }
+
+  variant numeric {
+    number(f64),
+    bigint(s64),
+  }
+
+  record stats {
+    dev: numeric,
+    ino: numeric,
+    mode: numeric,
+    nlink: numeric,
+    uid: numeric,
+    gid: numeric,
+    rdev: numeric,
+    size: numeric,
+    blksize: numeric,
+    blocks: numeric,
+    atime-ms: numeric,
+    mtime-ms: numeric,
+    ctime-ms: numeric,
+    birthtime-ms: numeric,
+    atime-ns: option<s64>,
+    mtime-ns: option<s64>,
+    ctime-ns: option<s64>,
+    birthtime-ns: option<s64>,
+    file-type: file-type,
+  }
+
+  record statfs-result {
+    %type: numeric,
+    bsize: numeric,
+    blocks: numeric,
+    bfree: numeric,
+    bavail: numeric,
+    files: numeric,
+    ffree: numeric,
+  }
+
+  record dirent {
+    name: string,
+    parent-path: string,
+    file-type: file-type,
+  }
+
+  variant directory-entry {
+    name(string),
+    dirent(dirent),
+  }
+
+  variant glob-entry {
+    path(string),
+    dirent(dirent),
+  }
+
+  variant glob-exclude {
+    pattern(string),
+    patterns(list<string>),
+  }
+
+  record copy-options {
+    dereference: bool,
+    error-on-exist: bool,
+    force: bool,
+    preserve-timestamps: bool,
+    recursive: bool,
+    verbatim-symlinks: bool,
+  }
+
+  record glob-options {
+    cwd: option<path>,
+    exclude: option<glob-exclude>,
+    with-file-types: bool,
+  }
+
+  record mkdir-options {
+    recursive: bool,
+    mode: option<mode>,
+  }
+
+  record readdir-options {
+    recursive: bool,
+    with-file-types: bool,
+  }
+
+  record remove-options {
+    force: bool,
+    max-retries: u32,
+    recursive: bool,
+    retry-delay: u32,
+  }
+
+  record stat-options {
+    bigint: bool,
+    throw-if-no-entry: bool,
+  }
+
+  record read-file-options {
+    flag: option<string>,
+  }
+
+  record write-file-options {
+    flag: option<string>,
+    mode: option<mode>,
+    flush: bool,
+  }
+
+  record read-result {
+    bytes-read: u32,
+    data: list<u8>,
+  }
+
+  record readv-result {
+    bytes-read: u32,
+    buffers: list<list<u8>>,
+  }
+
+  access: func(path: path, mode: s32) -> result<_, error>;
+  append-file: func(file: path-or-descriptor, data: list<u8>, options: write-file-options) -> result<_, error>;
+  chmod: func(path: path, mode: mode) -> result<_, error>;
+  chown: func(path: path, uid: u32, gid: u32) -> result<_, error>;
+  close: func(descriptor: u32) -> result<_, error>;
+  copy-file: func(source: path, destination: path, mode: s32) -> result<_, error>;
+  cp: func(source: path, destination: path, options: copy-options) -> result<_, error>;
+  exists: func(path: path) -> result<bool, error>;
+  fchmod: func(descriptor: u32, mode: mode) -> result<_, error>;
+  fchown: func(descriptor: u32, uid: u32, gid: u32) -> result<_, error>;
+  fdatasync: func(descriptor: u32) -> result<_, error>;
+  fstat: func(descriptor: u32, options: stat-options) -> result<stats, error>;
+  fsync: func(descriptor: u32) -> result<_, error>;
+  ftruncate: func(descriptor: u32, length: u32) -> result<_, error>;
+  futimes: func(descriptor: u32, atime: f64, mtime: f64) -> result<_, error>;
+  glob: func(patterns: list<string>, options: glob-options) -> result<list<glob-entry>, error>;
+  lchown: func(path: path, uid: u32, gid: u32) -> result<_, error>;
+  link: func(existing-path: path, new-path: path) -> result<_, error>;
+  lstat: func(path: path, options: stat-options) -> result<option<stats>, error>;
+  lutimes: func(path: path, atime: f64, mtime: f64) -> result<_, error>;
+  mkdir: func(path: path, options: mkdir-options) -> result<option<string>, error>;
+  mkdtemp: func(prefix: string) -> result<string, error>;
+  open: func(path: path, %flags: open-mode, mode: mode) -> result<u32, error>;
+  read-file: func(file: path-or-descriptor, options: read-file-options) -> result<list<u8>, error>;
+  readdir: func(path: path, options: readdir-options) -> result<list<directory-entry>, error>;
+  readlink: func(path: path) -> result<string, error>;
+  realpath: func(path: path) -> result<string, error>;
+  rename: func(old-path: path, new-path: path) -> result<_, error>;
+  rm: func(path: path, options: remove-options) -> result<_, error>;
+  rmdir: func(path: path, options: remove-options) -> result<_, error>;
+  stat: func(path: path, options: stat-options) -> result<option<stats>, error>;
+  statfs: func(path: path, bigint: bool) -> result<statfs-result, error>;
+  symlink: func(target: path, path: path, %type: option<string>) -> result<_, error>;
+  truncate: func(path: path, length: u32) -> result<_, error>;
+  unlink: func(path: path) -> result<_, error>;
+  utimes: func(path: path, atime: f64, mtime: f64) -> result<_, error>;
+  write-file: func(file: path-or-descriptor, data: list<u8>, options: write-file-options) -> result<_, error>;
+  read: func(descriptor: u32, length: u32, position: option<u64>) -> result<read-result, error>;
+  write: func(descriptor: u32, data: list<u8>, position: option<u64>) -> result<u32, error>;
+  readv: func(descriptor: u32, lengths: list<u32>, position: option<u64>) -> result<readv-result, error>;
+  writev: func(descriptor: u32, buffers: list<list<u8>>, position: option<u64>) -> result<u32, error>;
+}

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

@@ -0,0 +1,151 @@
+package jco:node@0.1.0;
+
+/// Guest-owned callback resources used by the direct Node-compatible HTTP implementation.
+interface http-callbacks {
+  variant errno {
+    number(s64),
+    symbolic(string),
+  }
+
+  record error {
+    name: string,
+    message: string,
+    code: option<string>,
+    errno: option<errno>,
+    syscall: option<string>,
+    hostname: option<string>,
+    address: option<string>,
+    port: option<u16>,
+  }
+
+  record header {
+    name: string,
+    value: list<u8>,
+  }
+
+  record incoming-request {
+    method: string,
+    url: string,
+    http-version: string,
+    headers: list<header>,
+    body: list<u8>,
+    remote-address: option<string>,
+    remote-port: option<u16>,
+  }
+
+  record outgoing-response {
+    status-code: u16,
+    status-message: string,
+    headers: list<header>,
+    body: list<u8>,
+  }
+
+  resource request-listener {
+    handle: func(request: incoming-request) -> result<outgoing-response, error>;
+  }
+
+  /// Redeem a registration once. The host owns the returned listener until the server closes.
+  take-request-listener: func(id: u32) -> option<request-listener>;
+}
+
+/// Typed host boundary for Node-compatible HTTP clients and servers.
+interface http {
+  variant errno {
+    number(s64),
+    symbolic(string),
+  }
+
+  record error {
+    name: string,
+    message: string,
+    code: option<string>,
+    errno: option<errno>,
+    syscall: option<string>,
+    hostname: option<string>,
+    address: option<string>,
+    port: option<u16>,
+  }
+
+  record header {
+    name: string,
+    value: list<u8>,
+  }
+
+  record request-options {
+    method: string,
+    scheme: string,
+    authority: string,
+    path-with-query: string,
+    headers: list<header>,
+    body: list<u8>,
+    connect-timeout-ms: option<u32>,
+    first-byte-timeout-ms: option<u32>,
+    between-bytes-timeout-ms: option<u32>,
+    /// Set only for `https` requests that carry TLS options.
+    tls: option<tls-options>,
+  }
+
+  record response {
+    status-code: u16,
+    status-message: string,
+    http-version: string,
+    headers: list<header>,
+    body: list<u8>,
+  }
+
+  /// Configuration issued by the same jco:node/tls provider bound to this HTTP host.
+  record tls-options { context-id: u32 }
+
+  record server-options {
+    request-timeout: option<u32>,
+    headers-timeout: option<u32>,
+    keep-alive-timeout: option<u32>,
+    keep-alive-timeout-buffer: option<u32>,
+    connections-checking-interval: option<u32>,
+    max-header-size: option<u32>,
+    join-duplicate-headers: option<bool>,
+    no-delay: option<bool>,
+    require-host-header: option<bool>,
+    keep-alive: option<bool>,
+    keep-alive-initial-delay: option<u32>,
+    reject-non-standard-body-writes: option<bool>,
+    optimize-empty-requests: option<bool>,
+    /// Present for every `node:https` server, even when empty: the host terminates TLS.
+    tls: option<tls-options>,
+  }
+
+  record listen-options {
+    port: option<u16>,
+    host: option<string>,
+    backlog: option<u32>,
+    path: option<string>,
+    exclusive: option<bool>,
+    ipv6-only: option<bool>,
+    reuse-port: option<bool>,
+  }
+
+  record tcp-address {
+    address: string,
+    family: string,
+    port: u16,
+  }
+
+  variant server-address {
+    tcp(tcp-address),
+    pipe(string),
+  }
+
+  request: func(options: request-options) -> result<response, error>;
+
+  resource server {
+    constructor(options: server-options, listener: u32);
+    listen: func(options: listen-options) -> result<server-address, error>;
+    close: func() -> result<bool, error>;
+    close-all-connections: func() -> result<_, error>;
+    close-idle-connections: func() -> result<_, error>;
+    get-connections: func() -> result<u64, error>;
+    address: func() -> option<server-address>;
+    ref: func();
+    unref: func();
+  }
+}