@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.0

package/dist/types/process/kernel-streams.d.ts

@@ -0,0 +1,196 @@
+import type { HeldMeta, PollState } from '../kernel/fd-table.js';
+import type { MountLine, ProcessListing } from '../kernel/proc-info.js';
+import type { Termios } from '../kernel/tty.js';
+import type { EmscriptenFsForHook } from '../realm/emscripten-vfs-hook.js';
+export declare const O_NONBLOCK = 2048;
+export declare class ProcessExit extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+export declare class SyscallError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export interface ReadOptions {
+    nonblock?: boolean;
+    peek?: boolean;
+}
+export interface ProcessSys {
+    read(fd: number, max: number, opts?: ReadOptions): Uint8Array;
+    write(fd: number, bytes: Uint8Array, opts?: {
+        nonblock?: boolean;
+    }): number;
+    close(fd: number): void;
+    pipe(): [number, number];
+    poll(fd: number): PollState;
+    openVfs(path: string, flags: number, position: number, opts?: {
+        contents?: Uint8Array;
+        orphan?: boolean;
+        truncate?: boolean;
+        create?: boolean;
+        created?: boolean;
+        pin?: {
+            version: string;
+            size: number;
+        };
+        handle?: number;
+    }): number;
+    seek(fd: number, offset: number, whence: number): number;
+    flush(fd: number): void;
+    pread?(fd: number, max: number, at: number): Uint8Array;
+    pwrite?(fd: number, bytes: Uint8Array, at: number): number;
+    isatty?(fd: number): boolean;
+    ttyName?(fd: number): string | undefined;
+    kind?(fd: number): string | undefined;
+    heldMeta?(fd: number): HeldMeta | undefined;
+    access?(fd: number): 'read' | 'write' | undefined;
+    size?(fd: number): number;
+    fdStat?(fd: number): object | undefined;
+    fdChmod?(fd: number, mode: number): void;
+    fdChown?(fd: number, uid: number | undefined, gid: number | undefined): void;
+    fdUtimes?(fd: number, atimeMs: number | null, mtimeMs: number | null, now: boolean): void;
+    openTty?(name?: string): number;
+    ttyNames?(): string[];
+    ttyOwner?(name: string): TtyOwner | null;
+    tcgets?(fd: number): Termios;
+    tcsets?(fd: number, termios: Termios, flush?: boolean): void;
+    winsize?(fd: number): [number, number];
+    openPty?(): number;
+    openPts?(n: number, noctty: boolean): number;
+    ptyNumbers?(): number[];
+    openSealed?(flags: number): number;
+    openClipboard?(flags: number): number;
+    clipboardAbort?(fd: number): void;
+    procList?(): ProcessListing;
+    mountList?(): MountLine[];
+}
+export interface StreamOps {
+    getattr?: (stream: ProcessStream) => object;
+    llseek?: (stream: ProcessStream, offset: number, whence: number) => number;
+    read?: (stream: ProcessStream, buffer: Uint8Array, offset: number, length: number) => number;
+    write?: (stream: ProcessStream, buffer: Uint8Array, offset: number, length: number) => number;
+    close?: (stream: ProcessStream) => void;
+    dup?: (stream: ProcessStream) => void;
+    poll?: (stream: ProcessStream) => number;
+    fsync?: (stream: ProcessStream) => unknown;
+    mmap?: unknown;
+}
+export interface ProcessStream {
+    fd: number;
+    stream_ops: StreamOps;
+    sliccKernelFd?: number;
+    sliccKernelFile?: boolean;
+    sliccCloexec?: boolean;
+    sliccKernelSocket?: boolean;
+    path?: string;
+    flags: number;
+    position: number;
+    tty?: unknown;
+    node: {
+        mode: number;
+        mount?: {
+            type?: unknown;
+        };
+        node_ops?: {
+            getattr?: (node: ProcessStream['node']) => object;
+        };
+    };
+    shared: object;
+}
+export interface ProcessFs extends EmscriptenFsForHook {
+    streams: (ProcessStream | null | undefined)[];
+    getStream(fd: number): ProcessStream | null;
+    open(path: string, flags: number, mode?: number): ProcessStream;
+    dupStream(stream: ProcessStream, fd: number): ProcessStream;
+    closeStream(fd: number): void;
+    close?(stream: ProcessStream): void;
+    isFile(mode: number): boolean;
+    mkdirTree(path: string): void;
+    cwd(): string;
+    read(stream: ProcessStream, buffer: Uint8Array, offset: number, length: number, position?: number): number;
+    write(stream: ProcessStream, buffer: Uint8Array, offset: number, length: number): number;
+    stat?(path: string, dontFollow?: boolean): object;
+    writeFile?(path: string, data: string | Uint8Array): void;
+    fstat?(fd: number): object;
+    symlink?(target: string, path: string): void;
+    lookupPath?(path: string, opts?: {
+        follow?: boolean;
+    }): {
+        node: object;
+    };
+}
+export interface ProcessPipeFs {
+    createPipe(): {
+        readable_fd: number;
+        writable_fd: number;
+    };
+}
+export interface KernelStreamOptions {
+    sigpipe?: () => boolean;
+    restartable?: () => boolean;
+    owners?: boolean;
+    program?: string;
+}
+export interface TtyOwner {
+    uid: number;
+    gid: number;
+    mode?: number;
+}
+export declare class KernelStreams {
+    private readonly refs;
+    private socketRoot;
+    private sockets;
+    private readonly descriptions;
+    private described;
+    private readonly Fs;
+    private readonly sys;
+    private readonly options;
+    constructor(Fs: ProcessFs, sys: ProcessSys, options?: KernelStreamOptions);
+    attach(stream: ProcessStream, kfd: number, terminal?: boolean): void;
+    attachSocket(stream: ProcessStream, kfd: number): void;
+    socketStream(flags: number): ProcessStream;
+    nameTerminal(stream: ProcessStream): void;
+    private nameStream;
+    nameDevice(stream: ProcessStream, kind: 'sealed' | 'clipboard'): void;
+    private listSealed;
+    private openNode;
+    private readonly reporting;
+    reportClose(kfd: number): void;
+    quitting: boolean;
+    private atExit;
+    private failedAtExit;
+    private readonly committed;
+    exiting(): () => void;
+    private commitStdout;
+    exitStatus(status: number): number;
+    private reportedClose;
+    private stdoutFailed;
+    private creatingTerminal;
+    private useTerminalNodes;
+    private ttyNode;
+    private ttyOps;
+    attachFile(stream: ProcessStream, kfd: number): void;
+    sizeFromKernel(stream: ProcessStream, kfd: number): void;
+    describe(stream: ProcessStream, name: string, getattr: () => object): void;
+    private useDescriptions;
+    useKernelFdMetadata(): void;
+    useControllingTerminal(): void;
+    private openRacing;
+    private refuseExclusiveLink;
+    private openPty;
+    private openSealed;
+    private openClipboard;
+    private vessel;
+    private usePtyPaths;
+    private ownedTty;
+    private owned;
+    private existingPty;
+    private devicePath;
+    private terminalExists;
+    private openNamedTerminal;
+    private stdioTerminal;
+    usePipes(pipefs: ProcessPipeFs): void;
+    private restarting;
+    private call;
+    private ops;
+}

package/dist/types/process/process-fds.d.ts

@@ -0,0 +1,95 @@
+import type { MountLine } from '../kernel/proc-info.js';
+import type { ProcessFs, ProcessStream, ProcessSys } from './kernel-streams.js';
+import { type LockDeps } from './process-locks.js';
+import { type PtyKernel } from './process-pty.js';
+export declare const O_CLOEXEC = 524288;
+type CloexecStream = Pick<ProcessStream, 'sliccCloexec'>;
+export declare function closesOnExec(stream: CloexecStream): boolean;
+export declare function setCloseOnExec(stream: CloexecStream, on: boolean): void;
+export declare function trackCloseOnExec(Fs: ProcessFs): void;
+export type GlueSyscall = (...args: number[]) => number;
+export interface GlueSyscalls {
+    fcntl?: GlueSyscall;
+    pipe2?: GlueSyscall;
+    dup3?: GlueSyscall;
+    socket?: GlueSyscall;
+    accept4?: GlueSyscall;
+    ioctl?: GlueSyscall;
+    setitimer?: GlueSyscall;
+}
+export interface CloexecDeps {
+    fs(): ProcessFs | undefined;
+    heap(): Int32Array | undefined;
+    pty?: PtyKernel;
+    timer?: {
+        arm(ms: number): void;
+    };
+    locks?: Omit<LockDeps, 'fs'>;
+}
+export declare function wrapCloexecSyscalls(imports: WebAssembly.Imports, glue: GlueSyscalls | undefined, deps: CloexecDeps): void;
+export declare function pathOpensLinks(Fs: ProcessFs): void;
+type Syscall = (...args: number[]) => number;
+export interface KernelImports {
+    openat?: unknown;
+    mkdirat?: unknown;
+    mknodat?: unknown;
+    umask?: unknown;
+    faccessat?: unknown;
+    linkat?: unknown;
+    symlinkat?: unknown;
+    uname?: unknown;
+    utimensat?: unknown;
+    getppid?: unknown;
+    resizeHeap?: unknown;
+    fdWrite?: unknown;
+    fdRead?: unknown;
+    sleepMs?: unknown;
+}
+export declare function importKey(namespace: WebAssembly.ModuleImports, name: keyof KernelImports, glue: KernelImports | undefined): string | undefined;
+export declare function wrapImport(imports: WebAssembly.Imports, name: keyof KernelImports, glue: KernelImports | undefined, wrap: (original: Syscall) => Syscall, optional?: boolean): void;
+export interface UmaskDeps {
+    initial: number;
+    memory(): WebAssembly.Memory | undefined;
+    set(mask: number): void;
+    glue?: KernelImports | undefined;
+}
+export declare function kernelUmask(imports: WebAssembly.Imports, deps: UmaskDeps): void;
+export declare function noFollowUtimes(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, glue?: unknown, memory?: () => WebAssembly.Memory | undefined): void;
+export interface FdImports {
+    fd_sync?: unknown;
+    fd_pread?: unknown;
+    fd_pwrite?: unknown;
+}
+export declare function syncFsync(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, glue?: FdImports): void;
+interface PositionalDeps {
+    glue?: FdImports | undefined;
+    fs: () => ProcessFs | undefined;
+    sys: Pick<ProcessSys, 'pread' | 'pwrite'>;
+    memory: () => WebAssembly.Memory | undefined;
+}
+export declare function positionalIo(imports: WebAssembly.Imports, deps: PositionalDeps): void;
+export type Memalign = (alignment: number, size: number) => number;
+export interface MmapDeps {
+    sys: Pick<ProcessSys, 'pread'>;
+    memory: () => WebAssembly.Memory | undefined;
+    memalign: () => Memalign | undefined;
+}
+export declare function useFileMmap(Fs: ProcessFs, deps: MmapDeps): void;
+export declare function wasmMemory(instance: WebAssembly.Instance, imports: WebAssembly.Imports): WebAssembly.Memory | undefined;
+export declare function fdOfPath(path: string, cwd: string): number | undefined;
+export declare function useZeroDevices(Fs: ProcessFs): void;
+export declare function useDevRemoval(Fs: ProcessFs): void;
+export declare function useDevFd(Fs: ProcessFs): void;
+export declare function pinRootKind(): void;
+export declare function mountTable(mounts?: MountLine[]): string;
+export declare function accounts(env?: Record<string, string>): {
+    passwd: string;
+    group: string;
+};
+export declare function useMounts(Fs: ProcessFs, env?: Record<string, string>, live?: boolean): void;
+export declare function kernelAccess(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, memory: () => WebAssembly.Memory | undefined, glue?: KernelImports): void;
+export declare function kernelLink(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, memory: () => WebAssembly.Memory | undefined, glue?: KernelImports): void;
+export declare function devCreations(imports: WebAssembly.Imports, fs: () => ProcessFs | undefined, memory: () => WebAssembly.Memory | undefined, glue?: KernelImports): void;
+export declare function kernelUname(imports: WebAssembly.Imports, hostname: string, memory: () => WebAssembly.Memory | undefined, glue?: KernelImports): void;
+export declare function linuxDevices(Fs: ProcessFs): void;
+export {};

package/dist/types/process/process-locks.d.ts

@@ -0,0 +1,29 @@
+import type { ProcessFs, ProcessStream } from './kernel-streams.js';
+export declare const F_GETLK = 12;
+export declare const F_SETLK = 13;
+export declare const F_SETLKW = 14;
+export type LockKind = 'read' | 'write';
+export interface LockTarget {
+    path?: string;
+    fd?: number;
+}
+export interface LockHeld {
+    kind: LockKind;
+    pid: number;
+    start: number;
+    len: number;
+}
+export interface LockKernel {
+    setLock(target: LockTarget, kind: LockKind | 'unlock', start: number, len: number, wait: boolean): void;
+    getLock(target: LockTarget, kind: LockKind, start: number, len: number): LockHeld | null;
+    closeLocks(target: LockTarget): void;
+}
+export interface LockDeps {
+    fs(): ProcessFs | undefined;
+    memory(): ArrayBufferLike | undefined;
+    kernel: LockKernel;
+    flush(): void;
+}
+export declare function lockTarget(stream: ProcessStream): LockTarget | undefined;
+export declare function recordLock(fcntl: (fd: number, cmd: number, varargs: number) => number, deps: LockDeps): (fd: number, cmd: number, varargs: number) => number;
+export declare function closeDropsLocks(Fs: ProcessFs, kernel: LockKernel): void;

package/dist/types/process/process-pty.d.ts

@@ -0,0 +1,20 @@
+import type { ProcessFs } from './kernel-streams.js';
+import type { GlueSyscall } from './process-fds.js';
+export declare const TIOCGPTN = 2147767344;
+export declare const TIOCSPTLCK = 1074025521;
+export declare const TIOCSCTTY = 21518;
+export declare const TIOCSWINSZ = 21524;
+export declare const TIOCPKT = 21536;
+export interface PtyKernel {
+    ptyNumber(kfd: number): number;
+    ptyLock(kfd: number, lock: boolean): void;
+    setControllingTerminal(kfd: number): void;
+    setPacketMode(kfd: number, on: boolean): void;
+    setWinsize(kfd: number, rows: number, cols: number): void;
+}
+export interface PtyIoctlDeps {
+    fs(): ProcessFs | undefined;
+    heap(): Int32Array | undefined;
+    kernel: PtyKernel;
+}
+export declare function ptyIoctl(ioctl: GlueSyscall, deps: PtyIoctlDeps): GlueSyscall;

package/dist/types/process/process-signals.d.ts

@@ -0,0 +1,33 @@
+import type { SyncSabTransport } from '../realm/sync-sab-bridge.js';
+export interface SignalHooks {
+    masks(): {
+        caught: number;
+        ignored: number;
+        restart: number;
+        defaults?: number;
+    } | null;
+    raise(sig: number): void;
+    timer?(which: number): void;
+    killed?(code: number): void;
+}
+export declare class SignalGate {
+    private reported;
+    private restart;
+    private lastDelivered;
+    private depth;
+    private reporting;
+    private unwinding;
+    private quieted;
+    private delivered;
+    private readonly raw;
+    private readonly header;
+    private readonly hooks;
+    constructor(raw: SyncSabTransport, header: Int32Array, hooks: SignalHooks);
+    transport(): SyncSabTransport;
+    deliveries(): number;
+    restartable(): boolean;
+    private report;
+    quiet<T>(fn: () => T): T;
+    interrupt(): boolean;
+    deliver(): void;
+}

package/dist/types/process/procfs.d.ts

@@ -0,0 +1,41 @@
+import type { MountLine, ProcessInfo, ProcessListing } from '../kernel/proc-info.js';
+export declare const PID_FILES: readonly ['cmdline', 'comm', 'stat', 'statm', 'status'];
+export declare const SYSTEM_FILES: readonly ['loadavg', 'meminfo', 'stat', 'uptime', 'version'];
+export interface ProcSysTree {
+    readonly [name: string]: string | ProcSysTree;
+}
+export declare const SYS_TREE: ProcSysTree;
+export declare function sysEntry(parts: readonly string[]): string | ProcSysTree | undefined;
+type PidFile = (typeof PID_FILES)[number];
+type SystemFile = (typeof SYSTEM_FILES)[number];
+export interface ProcSys {
+    procList?(): ProcessListing;
+    mountList?(): MountLine[];
+}
+export interface MemorySource {
+    deviceMemory?: number;
+    usedHeap?: number;
+}
+export declare function commOf(info: ProcessInfo): string;
+export declare function ttyNumber(tty: string | null): number;
+export declare function pidStat(info: ProcessInfo, boot: number, state?: string): string;
+export declare function taskStat(info: ProcessInfo, tid: number, boot: number): string | undefined;
+export declare function taskIds(info: ProcessInfo): number[];
+export declare function pidStatus(info: ProcessInfo): string;
+export declare function pidFile(name: PidFile, info: ProcessInfo, boot: number): string;
+export declare function memoryInfo(source: MemorySource, used?: number): string;
+export declare function systemFile(name: SystemFile, listing: ProcessListing, now: number, memory: MemorySource): string;
+export declare function memorySource(scope?: object): MemorySource;
+export interface ProcFs {
+    lookupPath?(path: string, opts?: {
+        follow?: boolean;
+    }): {
+        node: object;
+    };
+    createNode?(parent: object, name: string, mode: number, rdev: number): object;
+    hashRemoveNode?(node: object): void;
+    streams?: unknown[];
+    ErrnoError: new (errno: number) => Error;
+}
+export declare function useProcfs(Fs: ProcFs, sys: ProcSys, pid: number, memory?: MemorySource): void;
+export {};

package/dist/types/process/wasi/dylink.d.ts

@@ -0,0 +1,9 @@
+export interface DylinkInfo {
+    memorySize: number;
+    memoryAlign: number;
+    tableSize: number;
+    tableAlign: number;
+    needed: string[];
+    runtimePath: string[];
+}
+export declare function dylinkInfo(module: WebAssembly.Module): DylinkInfo | undefined;

package/dist/types/process/wasi/slicc-lock.d.ts

@@ -0,0 +1,26 @@
+import type { LockHeld, LockKind, LockTarget } from '../process-locks.js';
+import type { WasiFunction } from './wasi-host.js';
+import type { WasiMemory } from './wasi-memory.js';
+export declare const F_GETLK = 12;
+export declare const F_SETLK = 13;
+export declare const F_SETLKW = 14;
+export interface LockedFile {
+    target: LockTarget;
+    path?: string;
+    readable?: boolean;
+    writable?: boolean;
+    offset(): number;
+    size(): number;
+}
+export interface LockCalls {
+    set(target: LockTarget, kind: LockKind | 'unlock', start: number, len: number, wait: boolean): void;
+    get(target: LockTarget, kind: LockKind, start: number, len: number): LockHeld | null;
+}
+export interface LockHost {
+    mem: WasiMemory;
+    file(fd: number): LockedFile;
+    flush(file: LockedFile): void;
+    locked(): void;
+    calls: LockCalls;
+}
+export declare function lockImports(host: LockHost): Record<string, WasiFunction>;

package/dist/types/process/wasi/slicc-sem.d.ts

@@ -0,0 +1,3 @@
+import type { WasiFunction, WasiHost } from './wasi-host.js';
+export declare function remainingMs(deadline: bigint, now: bigint): number;
+export declare function semImports(host: WasiHost): Record<string, WasiFunction>;

package/dist/types/process/wasi/wasi-abi.d.ts

@@ -0,0 +1,156 @@
+export declare const E: {
+    readonly SUCCESS: 0;
+    readonly '2BIG': 1;
+    readonly ACCES: 2;
+    readonly ADDRINUSE: 3;
+    readonly ADDRNOTAVAIL: 4;
+    readonly AFNOSUPPORT: 5;
+    readonly AGAIN: 6;
+    readonly ALREADY: 7;
+    readonly BADF: 8;
+    readonly BADMSG: 9;
+    readonly BUSY: 10;
+    readonly CANCELED: 11;
+    readonly CHILD: 12;
+    readonly CONNABORTED: 13;
+    readonly CONNREFUSED: 14;
+    readonly CONNRESET: 15;
+    readonly DEADLK: 16;
+    readonly DESTADDRREQ: 17;
+    readonly DOM: 18;
+    readonly DQUOT: 19;
+    readonly EXIST: 20;
+    readonly FAULT: 21;
+    readonly FBIG: 22;
+    readonly HOSTUNREACH: 23;
+    readonly IDRM: 24;
+    readonly ILSEQ: 25;
+    readonly INPROGRESS: 26;
+    readonly INTR: 27;
+    readonly INVAL: 28;
+    readonly IO: 29;
+    readonly ISCONN: 30;
+    readonly ISDIR: 31;
+    readonly LOOP: 32;
+    readonly MFILE: 33;
+    readonly MLINK: 34;
+    readonly MSGSIZE: 35;
+    readonly MULTIHOP: 36;
+    readonly NAMETOOLONG: 37;
+    readonly NETDOWN: 38;
+    readonly NETRESET: 39;
+    readonly NETUNREACH: 40;
+    readonly NFILE: 41;
+    readonly NOBUFS: 42;
+    readonly NODEV: 43;
+    readonly NOENT: 44;
+    readonly NOEXEC: 45;
+    readonly NOLCK: 46;
+    readonly NOLINK: 47;
+    readonly NOMEM: 48;
+    readonly NOMSG: 49;
+    readonly NOPROTOOPT: 50;
+    readonly NOSPC: 51;
+    readonly NOSYS: 52;
+    readonly NOTCONN: 53;
+    readonly NOTDIR: 54;
+    readonly NOTEMPTY: 55;
+    readonly NOTRECOVERABLE: 56;
+    readonly NOTSOCK: 57;
+    readonly NOTSUP: 58;
+    readonly NOTTY: 59;
+    readonly NXIO: 60;
+    readonly OVERFLOW: 61;
+    readonly OWNERDEAD: 62;
+    readonly PERM: 63;
+    readonly PIPE: 64;
+    readonly PROTO: 65;
+    readonly PROTONOSUPPORT: 66;
+    readonly PROTOTYPE: 67;
+    readonly RANGE: 68;
+    readonly ROFS: 69;
+    readonly SPIPE: 70;
+    readonly SRCH: 71;
+    readonly STALE: 72;
+    readonly TIMEDOUT: 73;
+    readonly TXTBSY: 74;
+    readonly XDEV: 75;
+    readonly NOTCAPABLE: 76;
+};
+export declare function wasiErrnoOf(code: string | undefined): number;
+export declare const FILETYPE: {
+    readonly UNKNOWN: 0;
+    readonly BLOCK_DEVICE: 1;
+    readonly CHARACTER_DEVICE: 2;
+    readonly DIRECTORY: 3;
+    readonly REGULAR_FILE: 4;
+    readonly SOCKET_DGRAM: 5;
+    readonly SOCKET_STREAM: 6;
+    readonly SYMBOLIC_LINK: 7;
+};
+export declare const RIGHTS: {
+    readonly FD_DATASYNC: bigint;
+    readonly FD_READ: bigint;
+    readonly FD_SEEK: bigint;
+    readonly FD_FDSTAT_SET_FLAGS: bigint;
+    readonly FD_SYNC: bigint;
+    readonly FD_TELL: bigint;
+    readonly FD_WRITE: bigint;
+    readonly ALL: bigint;
+};
+export declare const OFLAGS: {
+    readonly CREAT: 1;
+    readonly DIRECTORY: 2;
+    readonly EXCL: 4;
+    readonly TRUNC: 8;
+};
+export declare const FDFLAGS: {
+    readonly APPEND: 1;
+    readonly DSYNC: 2;
+    readonly NONBLOCK: 4;
+    readonly RSYNC: 8;
+    readonly SYNC: 16;
+};
+export declare const LOOKUP_SYMLINK_FOLLOW = 1;
+export declare const WHENCE: {
+    readonly SET: 0;
+    readonly CUR: 1;
+    readonly END: 2;
+};
+export declare const CLOCK: {
+    readonly REALTIME: 0;
+    readonly MONOTONIC: 1;
+    readonly PROCESS_CPUTIME: 2;
+    readonly THREAD_CPUTIME: 3;
+};
+export declare const FSTFLAGS: {
+    readonly ATIM: 1;
+    readonly ATIM_NOW: 2;
+    readonly MTIM: 4;
+    readonly MTIM_NOW: 8;
+};
+export declare const EVENTTYPE: {
+    readonly CLOCK: 0;
+    readonly FD_READ: 1;
+    readonly FD_WRITE: 2;
+};
+export declare const SUBCLOCK_ABSTIME = 1;
+export declare const EVENT_FD_READWRITE_HANGUP = 1;
+export declare const RIFLAGS: {
+    readonly PEEK: 1;
+    readonly WAITALL: 2;
+};
+export declare const SDFLAGS: {
+    readonly RD: 1;
+    readonly WR: 2;
+};
+export declare const PREOPENTYPE_DIR = 0;
+export declare const SIZE: {
+    readonly FILESTAT: 64;
+    readonly FDSTAT: 24;
+    readonly DIRENT: 24;
+    readonly SUBSCRIPTION: 48;
+    readonly EVENT: 32;
+};
+export declare const WASI_SIGNAL_TO_POSIX: Readonly<Record<number, number>>;
+export declare function wasixSignal(sig: number): number | undefined;