@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.1

package/dist/types/kernel/net/loopback-transport.d.ts

@@ -0,0 +1,13 @@
+import type { ConnectorStamp, LoopbackNet, PeerCred } from '../socket.js';
+import type { RealmTransportRequest, RealmTransportResponse, RealmTransportTraits, RealmWebSocket, RealmWebSocketRequest } from './transport.js';
+export declare const LOOPBACK_TRAITS: RealmTransportTraits;
+export declare class KernelLoopback {
+    private readonly net;
+    private readonly cred;
+    private readonly stamp?;
+    constructor(net: LoopbackNet, cred: () => PeerCred, stamp?: () => Promise<ConnectorStamp>);
+    port(url: string): number | undefined;
+    private connect;
+    fetch(req: RealmTransportRequest, port: number): Promise<RealmTransportResponse>;
+    websocket(req: RealmWebSocketRequest, port: number): Promise<RealmWebSocket>;
+}

package/dist/types/kernel/net/network.d.ts

@@ -0,0 +1,29 @@
+import type { KernelFs } from '../../fs/types.js';
+import type { LoopbackNet } from '../socket.js';
+import { RealmProxy } from './proxy-service.js';
+import { type CaStore, type RealmCa } from './realm-ca.js';
+import { type TlsEngine, type TlsEngineModule } from './tls-engine.js';
+import type { RealmTransport } from './transport.js';
+export declare const NO_TRANSPORT = "slicc-kernel: no network transport (createKernel({ network: { transport } }))";
+export declare const TLS_ENGINE_PACKAGE = "@ai-ecoverse/wasm-tls-engine";
+export declare const CA_PATH = "/etc/ssl/certs/slicc-kernel-ca.pem";
+export declare const CA_DB = "slicc-kernel-ca";
+export declare function networkEnv(hostname?: string): Record<string, string>;
+export declare function missingTransport(): RealmTransport;
+export declare function memoryCaStore(): CaStore;
+export declare function caStore(name: string | false): CaStore;
+export declare function packageTlsEngine(fs: KernelFs, modules: string): () => Promise<TlsEngineModule>;
+export interface NetworkOptions {
+    transport?: RealmTransport;
+    engine: () => Promise<TlsEngine>;
+    ca: () => Promise<RealmCa>;
+    now?: () => number;
+}
+export declare function kernelCa(store: CaStore): () => Promise<RealmCa>;
+export declare function kernelTlsEngine(load: () => Promise<TlsEngineModule>): () => Promise<TlsEngine>;
+export declare const CA_BUNDLE_MAX = 16;
+export interface LockLike {
+    request<T>(name: string, run: () => Promise<T>): Promise<T>;
+}
+export declare function writeCaFile(fs: KernelFs, ca: () => Promise<RealmCa>, locks?: LockLike | undefined): Promise<void>;
+export declare function enableNetwork(net: LoopbackNet, options: NetworkOptions): () => RealmProxy | undefined;

package/dist/types/kernel/net/proxy-service.d.ts

@@ -0,0 +1,70 @@
+import type { KernelSocket, LoopbackNet } from '../socket.js';
+import { type ByteSource, Incoming, type RequestHead } from './http1.js';
+import type { HeaderList, RealmTransport } from './transport.js';
+export declare const NO_WEBSOCKET = "WebSocket not supported by this transport (fetchTransport needs { webSocket: true })";
+export declare const REALM_PROXY_PORT = 3128;
+export interface ProxyLimits {
+    maxConnections: number;
+    maxHead: number;
+    idleMs: number;
+    bodyBudget: number;
+    closeWaitMs: number;
+}
+export interface TunnelTarget {
+    host: string;
+    port: number;
+}
+export interface HttpSink {
+    write(bytes: Uint8Array, signal?: AbortSignal): Promise<unknown>;
+}
+export type ServeHttp = (source: ByteSource, sink: HttpSink, origin: string) => Promise<void>;
+export type TunnelHandler = (conn: KernelSocket, incoming: Incoming, target: TunnelTarget, signal: AbortSignal, serveHttp: ServeHttp) => Promise<void>;
+export interface RealmProxyOptions {
+    net: LoopbackNet;
+    transport: RealmTransport;
+    host?: string;
+    port?: number;
+    tunnel?: TunnelHandler;
+    tunnelReady?: () => Promise<void>;
+    limits?: Partial<ProxyLimits>;
+}
+export declare function canonicalHost(host: string): string | undefined;
+export declare function isLoopbackHost(hostname: string): boolean;
+export declare function forwardRequestHeaders(headers: HeaderList): HeaderList;
+export declare function forwardResponseHeaders(headers: HeaderList, opts: {
+    encodedBodies: boolean;
+    bodiless: boolean;
+}): Array<readonly [string, string]>;
+export declare function tunnelRequestUrl(req: RequestHead, origin: string): string;
+export declare function requestUrl(req: RequestHead): string;
+export declare function tunnelTarget(req: RequestHead): TunnelTarget;
+export declare function watchHangup(conn: KernelSocket, abort: AbortController, until: AbortSignal): Promise<void>;
+export declare function webSocketTarget(req: RequestHead): RequestHead;
+export declare class RealmProxy {
+    private readonly options;
+    private readonly listener;
+    private readonly stop;
+    private readonly limits;
+    private readonly slots;
+    private readonly bodies;
+    private readonly connections;
+    private warnedWebSocket;
+    readonly closed: Promise<void>;
+    readonly port: number;
+    constructor(options: RealmProxyOptions);
+    get stopped(): boolean;
+    close(): void;
+    private acceptLoop;
+    private serve;
+    private requests;
+    private refuse;
+    private exchange;
+    private cap;
+    private expectContinue;
+    private upstream;
+    private relay;
+    private connect;
+    private tunnelReady;
+    private websocket;
+    private bridge;
+}

package/dist/types/kernel/net/realm-ca.d.ts

@@ -0,0 +1,28 @@
+import { type DistinguishedName } from './x509.js';
+export interface CaRecord {
+    key: CryptoKey;
+    cert: Uint8Array;
+    spki: Uint8Array;
+    notAfter: number;
+    name: DistinguishedName;
+}
+export interface CaStore {
+    get(owner: string): Promise<CaRecord | undefined>;
+    swap(owner: string, expected: CaRecord | undefined, record: CaRecord): Promise<CaRecord>;
+}
+export declare function winner(current: CaRecord | undefined, expected: CaRecord | undefined, record: CaRecord): CaRecord | undefined;
+export declare const LEAF_LIFETIME: number;
+export declare function indexedDbCaStore(dbName?: string): CaStore;
+export declare class LeafNameError extends Error {
+}
+export declare function validLeafName(host: string): boolean;
+export declare class RealmCa {
+    private readonly record;
+    private constructor();
+    static open(owner: string, store: CaStore, now?: number): Promise<RealmCa>;
+    private static create;
+    get cert(): Uint8Array;
+    get pem(): string;
+    issue(host: string, spki: Uint8Array, now?: number): Promise<Uint8Array>;
+}
+export declare function realmCa(owner: string, store: CaStore): Promise<RealmCa>;

package/dist/types/kernel/net/redirect-hops.d.ts

@@ -0,0 +1,5 @@
+import type { RealmTransport } from './transport.js';
+export declare const HELD_MS = 30000;
+export declare const HELD_MAX = 64;
+export declare const HELD_PER_OWNER = 8;
+export declare function replayingHops(inner: RealmTransport, heldMs?: number): RealmTransport;

package/dist/types/kernel/net/remote-transport.d.ts

@@ -0,0 +1,98 @@
+import type { HeaderList, RealmRedirectHop, RealmTransport, RealmTransportRequest, RealmTransportResponse, RealmTransportTraits, RealmWebSocket, RealmWebSocketMessage, RealmWebSocketRequest } from './transport.js';
+export type TransportCall = {
+    net: 'fetch';
+    nid: number;
+    url: string;
+    method: string;
+    headers: HeaderList;
+    body?: Uint8Array;
+} | {
+    net: 'read';
+    nid: number;
+} | {
+    net: 'cancel';
+    nid: number;
+} | {
+    net: 'ws-open';
+    nid: number;
+    url: string;
+    protocols: string[];
+    headers: HeaderList;
+} | {
+    net: 'ws-send';
+    nid: number;
+    data: RealmWebSocketMessage;
+} | {
+    net: 'ws-close';
+    nid: number;
+    code?: number;
+    reason?: string;
+} | {
+    net: 'ws-consumed';
+    nid: number;
+    n: number;
+};
+export type TransportReply = {
+    net: 'head';
+    nid: number;
+    status: number;
+    statusText: string;
+    headers: HeaderList;
+    url?: string;
+    redirected?: boolean;
+    redirects?: readonly RealmRedirectHop[];
+} | {
+    net: 'chunk';
+    nid: number;
+    bytes: Uint8Array;
+} | {
+    net: 'end';
+    nid: number;
+} | {
+    net: 'error';
+    nid: number;
+    message: string;
+    status?: number;
+    code?: string;
+} | {
+    net: 'ws-opened';
+    nid: number;
+    protocol: string;
+} | {
+    net: 'ws-message';
+    nid: number;
+    data: RealmWebSocketMessage;
+} | {
+    net: 'ws-acked';
+    nid: number;
+    n: number;
+} | {
+    net: 'ws-closed';
+    nid: number;
+    code: number;
+    reason: string;
+};
+export interface TransportPort {
+    postMessage(message: TransportCall): void;
+}
+export declare class TransportError extends Error {
+    readonly status: number | undefined;
+    readonly code: string | undefined;
+    constructor(message: string, status?: number, code?: string);
+}
+export declare class RemoteTransport implements RealmTransport {
+    traits: RealmTransportTraits;
+    private readonly port;
+    private readonly waiting;
+    private nextId;
+    private readonly sockets;
+    private failure;
+    constructor(port: TransportPort, traits: RealmTransportTraits);
+    receive(reply: TransportReply): void;
+    private toSocket;
+    fail(error: Error): void;
+    private ask;
+    private cancel;
+    fetch(request: RealmTransportRequest): Promise<RealmTransportResponse>;
+    websocket(request: RealmWebSocketRequest): Promise<RealmWebSocket>;
+}

package/dist/types/kernel/net/resolver.d.ts

@@ -0,0 +1,29 @@
+import { type Routes } from './routes.js';
+import { type NetworkUplink, type ResolveFamily } from './uplink.js';
+export declare const RESOLVE_TTL_MAX = 60;
+export declare const RESOLVE_TIMEOUT_MS = 10000;
+export declare const RESOLVE_CACHE_MAX = 256;
+export interface ResolverOptions {
+    uplink?: NetworkUplink | undefined;
+    routes: Routes;
+    now?: () => number;
+    timeoutMs?: number;
+    log?: (message: string) => void;
+    hostname?: string;
+}
+export declare function hostsEntry(name: string, own?: readonly string[]): string | undefined;
+export declare class Resolver {
+    private readonly uplink;
+    private readonly routes;
+    private readonly now;
+    private readonly timeoutMs;
+    private readonly log;
+    private readonly own;
+    private readonly cache;
+    private readonly pending;
+    constructor(options: ResolverOptions);
+    resolve(name: string, family: ResolveFamily, blocking?: () => AbortSignal): Promise<string[]>;
+    private lookup;
+    private usable;
+    private remember;
+}

package/dist/types/kernel/net/routes.d.ts

@@ -0,0 +1,15 @@
+export interface RouteTable {
+    prefixes: readonly string[];
+    exit: boolean;
+}
+export type Destination = 'loopback' | 'host' | 'reserved' | 'uplink' | 'unreachable';
+export declare function ipv4Bytes(text: string): number[] | undefined;
+export declare function ipv6Groups(text: string): number[] | undefined;
+export declare class Routes {
+    private table;
+    private exit;
+    readonly ipv6: boolean;
+    constructor(ipv6?: boolean);
+    set(table: RouteTable): void;
+    classify(host: string): Destination;
+}

package/dist/types/kernel/net/tls-engine.d.ts

@@ -0,0 +1,46 @@
+type TlsExport = 'malloc' | 'free' | 'tls_last_error' | 'tls_strerror' | 'tls_leaf_new' | 'tls_leaf_spki' | 'tls_leaf_add_cert' | 'tls_leaf_free' | 'tls_session_new' | 'tls_feed' | 'tls_feed_eof' | 'tls_in_room' | 'tls_read' | 'tls_write' | 'tls_out_size' | 'tls_out_take' | 'tls_close' | 'tls_alpn_http11' | 'tls_session_free';
+export type TlsEngineModule = {
+    readonly HEAPU8: Uint8Array;
+} & {
+    readonly [K in TlsExport as `_${K}`]: (...args: number[]) => number;
+};
+export declare class TlsError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+export declare class TlsEngine {
+    private readonly m;
+    private readonly scratch;
+    constructor(m: TlsEngineModule);
+    private put;
+    private taken;
+    error(code: number, what: string): TlsError;
+    leaf(): TlsLeaf;
+    session(leaf: TlsLeaf, host: string): TlsSession;
+    withBytes<T>(bytes: Uint8Array, fn: (ptr: number) => T): T;
+    intoScratch(fn: (ptr: number, max: number) => number): number | Uint8Array;
+}
+export declare class TlsLeaf {
+    private readonly engine;
+    private readonly m;
+    readonly ptr: number;
+    constructor(engine: TlsEngine, m: TlsEngineModule, ptr: number);
+    spki(): Uint8Array;
+    addCert(der: Uint8Array): void;
+    release(): void;
+}
+export declare class TlsSession {
+    private readonly engine;
+    private readonly m;
+    private readonly ptr;
+    constructor(engine: TlsEngine, m: TlsEngineModule, ptr: number);
+    feed(bytes: Uint8Array): number;
+    feedEnd(): void;
+    read(): Uint8Array | 'more' | 'eof';
+    write(bytes: Uint8Array): number;
+    take(): Uint8Array;
+    close(): void;
+    free(): void;
+}
+export declare function loadTlsEngine(load: () => Promise<TlsEngineModule>): Promise<TlsEngine>;
+export {};

package/dist/types/kernel/net/tls-tunnel.d.ts

@@ -0,0 +1,35 @@
+import type { KernelSocket } from '../socket.js';
+import type { ByteSource } from './http1.js';
+import type { HttpSink, TunnelHandler, TunnelTarget } from './proxy-service.js';
+import { type RealmCa } from './realm-ca.js';
+import type { TlsEngine, TlsSession } from './tls-engine.js';
+export declare class TlsStream implements ByteSource, HttpSink {
+    private readonly session;
+    private readonly cipherIn;
+    private readonly cipherOut;
+    private pending;
+    private ended;
+    constructor(session: TlsSession, cipherIn: ByteSource, cipherOut: KernelSocket);
+    private flush;
+    private feedPending;
+    read(_max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    write(bytes: Uint8Array, signal?: AbortSignal): Promise<number>;
+    close(signal?: AbortSignal): Promise<void>;
+}
+export interface TlsTerminatorOptions {
+    ca: () => Promise<RealmCa>;
+    engine: () => Promise<TlsEngine>;
+    now?: () => number;
+}
+export declare class TlsTerminator {
+    private readonly options;
+    private readonly leaves;
+    private readonly now;
+    constructor(options: TlsTerminatorOptions);
+    private leafFor;
+    private drop;
+    private issue;
+    close(): Promise<void>;
+    readonly handler: TunnelHandler;
+}
+export declare function authority(target: TunnelTarget): string;

package/dist/types/kernel/net/transport.d.ts

@@ -0,0 +1,64 @@
+export type HeaderList = ReadonlyArray<readonly [name: string, value: string]>;
+export interface RealmTransportRequest {
+    url: string;
+    method: string;
+    headers: HeaderList;
+    body?: Uint8Array;
+    signal: AbortSignal;
+}
+export interface RealmRedirectHop {
+    status: number;
+    url: string;
+    headers: HeaderList;
+}
+export interface RealmTransportResponse {
+    url?: string;
+    redirected?: boolean;
+    redirects?: readonly RealmRedirectHop[];
+    status: number;
+    statusText: string;
+    headers: HeaderList;
+    body: AsyncIterable<Uint8Array>;
+    cancel(): Promise<void>;
+}
+export interface RealmTransportExit {
+    kind: 'local' | 'remote' | 'tailnet' | (string & {});
+    caps: readonly string[];
+    [detail: string]: unknown;
+}
+export interface RealmTransportTraits {
+    manualRedirects: boolean;
+    encodedBodies: boolean;
+    maxRequestBody: number;
+    crossOrigin?: 'cors' | 'any';
+    unavailable?: true;
+    websocket?: true;
+    redirectHops?: true;
+    exit?: RealmTransportExit;
+    [trait: string]: unknown;
+}
+export interface RealmWebSocketRequest {
+    url: string;
+    protocols: string[];
+    headers: HeaderList;
+    signal: AbortSignal;
+}
+export interface RealmWebSocketClose {
+    code: number;
+    reason: string;
+    wasClean?: boolean;
+}
+export type RealmWebSocketMessage = string | Uint8Array;
+export interface RealmWebSocket {
+    readonly protocol: string;
+    readonly buffered: number;
+    send(data: RealmWebSocketMessage): void;
+    readonly messages: AsyncIterable<RealmWebSocketMessage>;
+    close(code?: number, reason?: string): void;
+    readonly closed: Promise<RealmWebSocketClose>;
+}
+export interface RealmTransport {
+    readonly traits: RealmTransportTraits;
+    fetch(request: RealmTransportRequest, owner?: number): Promise<RealmTransportResponse>;
+    websocket?(request: RealmWebSocketRequest): Promise<RealmWebSocket>;
+}

package/dist/types/kernel/net/uplink-socket.d.ts

@@ -0,0 +1,11 @@
+import { KernelPipe } from '../pipe.js';
+import type { UplinkConn } from './uplink.js';
+export interface UplinkLink {
+    rx: KernelPipe;
+    tx: KernelPipe;
+}
+export declare function hostPort(text: string): {
+    host: string;
+    port: number;
+} | undefined;
+export declare function uplinkLink(conn: UplinkConn, onReset: () => void): UplinkLink;

package/dist/types/kernel/net/uplink.d.ts

@@ -0,0 +1,163 @@
+import { type RouteTable } from './routes.js';
+export interface UplinkTraits {
+    tcp: true;
+    udp: boolean;
+    ipv6: boolean;
+}
+export type ResolveFamily = 0 | 4 | 6;
+export interface ResolveAnswer {
+    addresses: string[];
+    ttl?: number;
+}
+export interface UplinkConn {
+    readonly localAddr: string;
+    readonly remoteAddr: string;
+    read(): Promise<Uint8Array | null>;
+    write(bytes: Uint8Array): Promise<number>;
+    closeWrite(): void;
+    close(): void;
+}
+export interface UplinkDial {
+    network: 'tcp';
+    host: string;
+    port: number;
+    signal: AbortSignal;
+}
+export interface UplinkDatagram {
+    bytes: Uint8Array;
+    host: string;
+    port: number;
+}
+export interface UplinkUnreachable {
+    error: string;
+    host: string;
+    port: number;
+}
+export type UplinkMessage = UplinkDatagram | UplinkUnreachable;
+export interface UplinkUdpOpen {
+    family: 4 | 6;
+    signal: AbortSignal;
+}
+export interface UplinkUdp {
+    readonly localAddr: string;
+    send(bytes: Uint8Array, host: string, port: number): Promise<void>;
+    readonly messages: AsyncIterable<UplinkMessage>;
+    close(): void;
+}
+export interface NetworkUplink {
+    readonly traits: UplinkTraits;
+    readonly routes?: RouteTable;
+    resolve(name: string, family: ResolveFamily, signal?: AbortSignal): Promise<string[] | ResolveAnswer>;
+    dial(req: UplinkDial): Promise<UplinkConn>;
+    udp?(req: UplinkUdpOpen): Promise<UplinkUdp>;
+}
+export declare function carriesUdp(uplink: NetworkUplink): boolean;
+export type UplinkCall = {
+    uplink: 'resolve';
+    uid: number;
+    name: string;
+    family: ResolveFamily;
+} | {
+    uplink: 'dial';
+    uid: number;
+    host: string;
+    port: number;
+} | {
+    uplink: 'cancel';
+    uid: number;
+} | {
+    uplink: 'read';
+    uid: number;
+    cid: number;
+} | {
+    uplink: 'write';
+    uid: number;
+    cid: number;
+    bytes: Uint8Array;
+} | {
+    uplink: 'close-write';
+    cid: number;
+} | {
+    uplink: 'close';
+    cid: number;
+} | {
+    uplink: 'udp-open';
+    uid: number;
+    family: 4 | 6;
+} | {
+    uplink: 'udp-send';
+    uid: number;
+    cid: number;
+    bytes: Uint8Array;
+    host: string;
+    port: number;
+} | {
+    uplink: 'udp-recv';
+    uid: number;
+    cid: number;
+} | {
+    uplink: 'udp-close';
+    cid: number;
+};
+export type UplinkReply = {
+    uplink: 'resolved';
+    uid: number;
+    addresses: string[];
+    ttl?: number;
+} | {
+    uplink: 'dialled';
+    uid: number;
+    cid: number;
+    localAddr: string;
+    remoteAddr: string;
+} | {
+    uplink: 'data';
+    uid: number;
+    bytes: Uint8Array | null;
+} | {
+    uplink: 'written';
+    uid: number;
+    n: number;
+} | {
+    uplink: 'udp-opened';
+    uid: number;
+    cid: number;
+    localAddr: string;
+} | {
+    uplink: 'udp-sent';
+    uid: number;
+} | {
+    uplink: 'udp-message';
+    uid: number;
+    message: UplinkMessage | null;
+} | {
+    uplink: 'error';
+    uid: number;
+    message: string;
+    code?: string;
+};
+export interface UplinkPeer {
+    postMessage(message: UplinkReply, transfer?: Transferable[]): void;
+}
+export interface UplinkPort {
+    postMessage(message: UplinkCall, transfer?: Transferable[]): void;
+}
+export interface UplinkServer {
+    answer(call: UplinkCall): void;
+    close(): void;
+}
+export declare function answerOf(result: string[] | ResolveAnswer): ResolveAnswer;
+export declare function serveUplink(peer: UplinkPeer, uplink: NetworkUplink): UplinkServer;
+export declare class RemoteUplink implements NetworkUplink {
+    readonly traits: UplinkTraits;
+    readonly routes: RouteTable | undefined;
+    private readonly port;
+    private readonly waiting;
+    private nextId;
+    constructor(port: UplinkPort, traits: UplinkTraits, routes?: RouteTable);
+    receive(reply: UplinkReply): void;
+    private ask;
+    resolve(name: string, family: ResolveFamily, signal?: AbortSignal): Promise<ResolveAnswer>;
+    dial(req: UplinkDial): Promise<UplinkConn>;
+    udp(req: UplinkUdpOpen): Promise<UplinkUdp>;
+}

package/dist/types/kernel/net/ws-queue.d.ts

@@ -0,0 +1,21 @@
+import type { RealmWebSocketClose, RealmWebSocketMessage } from './transport.js';
+export declare const INBOUND_LIMIT: number;
+export declare const MESSAGE_LIMIT: number;
+export declare const TOO_BIG = 1009;
+export declare function payloadSize(message: RealmWebSocketMessage): number;
+export declare class MessageQueue implements AsyncIterable<RealmWebSocketMessage> {
+    private readonly items;
+    private readonly limit;
+    private waiter;
+    private size;
+    private ended;
+    private readonly overflow;
+    private readonly taken;
+    readonly closed: Promise<RealmWebSocketClose>;
+    private settle;
+    constructor(overflow: () => void, limit?: number, taken?: (n: number) => void);
+    push(message: RealmWebSocketMessage): void;
+    end(close: RealmWebSocketClose): void;
+    private wake;
+    [Symbol.asyncIterator](): AsyncIterator<RealmWebSocketMessage>;
+}

package/dist/types/kernel/net/ws-syscalls.d.ts

@@ -0,0 +1,45 @@
+import type { SyncFsResult } from '../../realm/sync-fs-wire.js';
+import type { KernelLoopback } from './loopback-transport.js';
+import type { HeaderList, RealmTransport } from './transport.js';
+export type WsSyscall = {
+    op: 'net-ws-open';
+    url: string;
+    protocols: string[];
+    headers: HeaderList;
+} | {
+    op: 'net-ws-ready';
+    handle: number;
+} | {
+    op: 'net-ws-recv';
+    handle: number;
+} | {
+    op: 'net-ws-wait';
+    handle: number;
+} | {
+    op: 'net-ws-send';
+    handle: number;
+    text?: string;
+    body?: Uint8Array;
+} | {
+    op: 'net-ws-close';
+    handle: number;
+    code?: number;
+    reason?: string;
+};
+export declare const WS_OPS: readonly string[];
+export declare class WsHandles {
+    private readonly transport;
+    private readonly open;
+    private readonly next;
+    private readonly local;
+    constructor(transport: RealmTransport, next: () => number, local?: KernelLoopback);
+    owns(handle: number): boolean;
+    syscall(req: WsSyscall): Promise<SyncFsResult>;
+    private start;
+    private connect;
+    private recv;
+    private closed;
+    private send;
+    close(handle: number): void;
+    closeAll(): void;
+}