@ai-ecoverse/slicc-kernel 1.102.5 → 1.103.0

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;

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

@@ -0,0 +1,130 @@
+import { type DeviceAccess, type DeviceMeta, type KernelFdKind } from '../../kernel/fd-table.js';
+import type { WasmSyscall } from '../../kernel/process.js';
+import { type SyncFsBridgeStat, type SyncFsPosixBridge } from '../../realm/sync-fs-wire.js';
+import type { ProcessSys } from '../kernel-streams.js';
+import { type WasiEntry } from './wasi-files.js';
+export interface WasiKernel {
+    sys: ProcessSys;
+    call(req: WasmSyscall): unknown;
+}
+type Device = 'null' | 'zero' | 'full' | 'urandom';
+export type WasiForkFd = {
+    fd: number;
+    type: 'kernel';
+    nonblock: boolean;
+    append: boolean;
+} | {
+    fd: number;
+    type: 'dir';
+    path: string;
+    preopen?: string;
+    twin?: number;
+} | {
+    fd: number;
+    type: 'device';
+    device: Device;
+    access?: DeviceAccess;
+};
+export declare const SEALED_PATH = "/dev/sealed";
+export declare const CLIPBOARD_PATH = "/dev/clipboard";
+export declare function deviceOf(path: string): Device | undefined;
+export declare class WasiFds {
+    private readonly table;
+    private readonly buffers;
+    private readonly reported;
+    private readonly byId;
+    private readonly ids;
+    private readonly kernel;
+    private readonly fs;
+    constructor(kernel: WasiKernel, fs: SyncFsPosixBridge);
+    setup(cwd: string, inherited: ReadonlyArray<{
+        fd: number;
+        kind?: KernelFdKind;
+        flags?: number;
+        device?: DeviceMeta;
+    }>, root?: boolean): void;
+    private preopens;
+    find(fd: number): WasiEntry | undefined;
+    private shared;
+    private seen;
+    get isShared(): boolean;
+    share(ids: Int32Array, fresh: boolean): void;
+    private sync;
+    private bump;
+    private stdioEntry;
+    private fetch;
+    private listed;
+    private publishFlags;
+    setFlags(fd: number, nonblock: boolean, append: boolean): void;
+    setCloexec(fd: number, on: boolean): void;
+    cwd(): string | undefined;
+    terminals(): number[];
+    sockets(): number[];
+    adopt(fd: number, kind: KernelFdKind, nonblock: boolean, dgram?: boolean): void;
+    get(fd: number): WasiEntry;
+    preopen(fd: number): Extract<WasiEntry, {
+        type: 'dir';
+    }> & {
+        preopen: string;
+    };
+    dir(fd: number): Extract<WasiEntry, {
+        type: 'dir';
+    }>;
+    private install;
+    readonly cloexec: Set<number>;
+    implicitCloexec: boolean;
+    dup(fd: number, min: number, cloexec: boolean): number;
+    pipe(): [number, number];
+    chdir(path: string): void;
+    promoteFiles(): void;
+    snapshot(): WasiForkFd[];
+    restore(fds: readonly WasiForkFd[], cloexec: readonly number[]): void;
+    inheritable(): Map<number, number>;
+    private locking;
+    holdLocks(): void;
+    private dropLocks;
+    close(fd: number): void;
+    renumber(from: number, to: number, keep?: boolean): void;
+    private release;
+    private drop;
+    private forget;
+    private know;
+    private identity;
+    private sharing;
+    private learn;
+    linked(from: string, to: string): void;
+    private letGo;
+    kind(fd: number, e: Extract<WasiEntry, {
+        type: 'kernel';
+    }>): KernelFdKind;
+    datagram(fd: number, e: Extract<WasiEntry, {
+        type: 'kernel';
+    }>): boolean;
+    flushAll(): void;
+    flushEarly(): void;
+    flushPath(path: string): void;
+    holdsUnder(path: string): boolean;
+    unlinking(path: string, linked?: SyncFsBridgeStat): void;
+    unlinked(path: string, linked?: SyncFsBridgeStat): void;
+    private openedIno;
+    private inoOf;
+    private survives;
+    private detach;
+    renamed(from: string, to: string, replacedLinked?: SyncFsBridgeStat): void;
+    resolve(dirfd: number, path: string): string;
+    private openKernelDevice;
+    private openCharDevice;
+    open(path: string, oflags: number, rights: bigint, fdflags: number): number;
+    private regular;
+    private kernelHolds;
+    private readonly learned;
+    private named;
+    private file;
+    private freshBuffer;
+    private kernelFile;
+    private createNew;
+    private isLink;
+    private statOrMissing;
+    private reopen;
+}
+export {};

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

@@ -0,0 +1,99 @@
+import { type RangedWatch } from '../../fs/ranged.js';
+import type { DeviceAccess, KernelFdKind } from '../../kernel/fd-table.js';
+import type { SyncFsBridgeStat, SyncFsFileIo, SyncFsPosixBridge } from '../../realm/sync-fs-wire.js';
+export declare class WasiError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare class FileBuffer {
+    private data;
+    private length;
+    private dirty;
+    private whole;
+    private from;
+    private to;
+    private orphaned;
+    opens: number;
+    private readonly fs;
+    private where;
+    private readonly ranged;
+    private readonly watch;
+    private seen;
+    maxFile: number | undefined;
+    handle: number | undefined;
+    constructor(fs: SyncFsFileIo, path: string, empty: boolean, maxFile?: number, size?: number, version?: string, watch?: RangedWatch);
+    get path(): string;
+    set path(path: string);
+    get isRanged(): boolean;
+    get pin(): string | undefined;
+    keep(): void;
+    load(): Uint8Array;
+    size(): number;
+    pread(max: number, at: number): Uint8Array;
+    fits(end: number): void;
+    pwrite(bytes: Uint8Array, at: number): number;
+    append(bytes: Uint8Array): number | undefined;
+    truncate(size: number): void;
+    private ensure;
+    orphan(): void;
+    isOrphan(): boolean;
+    isDirty(): boolean;
+    contents(): Uint8Array;
+    flush(): void;
+}
+export declare class LocalFile {
+    offset: number;
+    refs: number;
+    readonly buffer: FileBuffer;
+    readonly readable: boolean;
+    readonly writable: boolean;
+    append: boolean;
+    constructor(buffer: FileBuffer, readable: boolean, writable: boolean, append: boolean);
+    get path(): string;
+    size(): number;
+    pread(max: number, at: number): Uint8Array;
+    read(max: number): Uint8Array;
+    pwrite(bytes: Uint8Array, at: number): number;
+    write(bytes: Uint8Array): number;
+    truncate(size: number): void;
+    flush(): void;
+}
+export interface DirListing {
+    names: string[];
+    stats: Map<string, SyncFsBridgeStat | null>;
+}
+export type WasiEntry = {
+    type: 'kernel';
+    kind?: KernelFdKind;
+    dgram?: boolean;
+    nonblock: boolean;
+    append: boolean;
+    path?: string;
+    ino?: number;
+} | {
+    type: 'file';
+    file: LocalFile;
+} | {
+    type: 'dir';
+    path: string;
+    preopen?: string;
+    twin?: number;
+    listing?: DirListing;
+} | {
+    type: 'device';
+    device: 'null' | 'zero' | 'full' | 'urandom';
+    access?: DeviceAccess;
+};
+export declare function normalize(path: string): string;
+export declare function physical(fs: Pick<SyncFsPosixBridge, 'lstat' | 'readlink' | 'access' | 'links'>, path: string): string;
+export declare function realOf(fs: Pick<SyncFsPosixBridge, 'lstat' | 'readlink'>, path: string): string;
+export declare function resolveUnder(dir: string, path: string): string;
+export declare function pathInode(path: string): bigint;
+export declare const MISS_TTL_MS = 20;
+export declare const FS_GEN = 4;
+export declare const SHARED_IDS_BYTES: number;
+export declare function cachingBridge(bridge: SyncFsPosixBridge, now?: () => number, shared?: Int32Array): SyncFsPosixBridge & {
+    invalidate(): void;
+    touched(path?: string, ino?: number): void;
+    threaded(): void;
+};

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

@@ -0,0 +1,104 @@
+import type { DeviceMeta, KernelFdKind } from '../../kernel/fd-table.js';
+import type { SyncFsPosixBridge } from '../../realm/sync-fs-wire.js';
+import { WasiFds, type WasiForkFd, type WasiKernel } from './wasi-fds.js';
+import { WasiMemory } from './wasi-memory.js';
+import type { WasiSigmask } from './wasi-sigmask.js';
+import type { WasiSignals } from './wasi-signals.js';
+import type { ThreadEntry } from './wasix-fork.js';
+export declare class WasiExit extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+export interface WasiHostOptions {
+    args: readonly string[];
+    env: Readonly<Record<string, string>>;
+    cwd: string;
+    pid: number;
+    ppid?: number;
+    parent?: () => number;
+    kernel: WasiKernel;
+    fs: SyncFsPosixBridge & {
+        invalidate?(): void;
+        touched?(path?: string, ino?: number): void;
+    };
+    inherited?: ReadonlyArray<{
+        fd: number;
+        kind?: KernelFdKind;
+        flags?: number;
+        device?: DeviceMeta;
+    }>;
+    shared?: Int32Array;
+    forked?: {
+        fds: readonly WasiForkFd[];
+        cloexec: readonly number[];
+    };
+    preopenRoot?: boolean;
+}
+export type WasiFunction = (...args: never[]) => number | undefined;
+export declare class WasiHost {
+    readonly mem: WasiMemory;
+    readonly fds: WasiFds;
+    private readonly started;
+    private cache;
+    private readonly startCwd;
+    interruptWakes: boolean;
+    entered: boolean;
+    onRaise: ((sig: number) => boolean) | undefined;
+    muted: ((fd: number, data: Uint8Array) => boolean) | undefined;
+    signals: WasiSignals | undefined;
+    sigmask: WasiSigmask | undefined;
+    linkedTls: (() => Array<[number, number]>) | undefined;
+    threadEntry: ThreadEntry | undefined;
+    linkedModules: (() => Record<string, WebAssembly.Module>) | undefined;
+    interrupted: (() => boolean) | undefined;
+    quietly: (fn: () => void) => void;
+    private readonly listening;
+    readonly o: WasiHostOptions;
+    constructor(o: WasiHostOptions);
+    get cwd(): string;
+    private created;
+    sliccTtyImports(): Record<string, WasiFunction>;
+    sliccFsImports(): Record<string, WasiFunction>;
+    sliccImports(): Record<string, WasiFunction>;
+    private poll;
+    private maskedPoll;
+    private suspend;
+    imports(): Record<string, WasiFunction>;
+    now(id: number): bigint;
+    private environ;
+    private processImports;
+    private ioImports;
+    private statImports;
+    private pathImports;
+    private socket;
+    private socketImports;
+    private recvAll;
+    private file;
+    private positional;
+    private readonly unnamed;
+    private changed;
+    private learnPath;
+    private lockedFile;
+    private kernelStat;
+    private write;
+    private read;
+    private local;
+    private seek;
+    private sync;
+    private fdstat;
+    private writeFilestat;
+    private fdFilestat;
+    private localFilestat;
+    private keptStat;
+    private sized;
+    private statOrphanable;
+    private synthetic;
+    private resolveForDev;
+    private pathFilestat;
+    private setTimes;
+    private readdir;
+    private list;
+    private lstatOrNull;
+    flushAll(): void;
+}
+export declare function wrap(table: Record<string, WasiFunction>): Record<string, WasiFunction>;

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

@@ -0,0 +1,16 @@
+export declare class WasiMemory {
+    private memory;
+    bind(memory: WebAssembly.Memory): void;
+    private buffer;
+    view(): DataView;
+    bytes(ptr: number, len: number): Uint8Array;
+    string(ptr: number, len: number): string;
+    cString(ptr: number): string;
+    size(): number;
+    iovecs(ptr: number, count: number): Array<[number, number]>;
+    capacity(ptr: number, count: number): number;
+    gather(ptr: number, count: number): Uint8Array;
+    scatter(ptr: number, count: number, data: Uint8Array): number;
+    putStrings(list: readonly string[], ptrs: number, buf: number): void;
+    putSizes(list: readonly string[], countPtr: number, sizePtr: number): void;
+}

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

@@ -0,0 +1,13 @@
+export interface ImportedMemory {
+    module: string;
+    name: string;
+    initial: number;
+    maximum?: number;
+    shared: boolean;
+}
+export declare function importedMemory(bytes: Uint8Array): ImportedMemory | undefined;
+export declare const RESERVED_NAMESPACES: ReadonlySet<string>;
+export type ForeignResult = 'none' | 'i32' | 'i64' | 'f32' | 'f64' | 'other';
+export type ForeignResults = Record<string, Record<string, ForeignResult>>;
+export declare function foreignImports(bytes: Uint8Array): ForeignResults | undefined;
+export declare function libcVersion(module: WebAssembly.Module): number | undefined;

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

@@ -0,0 +1,13 @@
+import type { WasiFds, WasiKernel } from './wasi-fds.js';
+import type { WasiMemory } from './wasi-memory.js';
+export type ClockNow = (id: number) => bigint;
+interface PollDeps {
+    mem: WasiMemory;
+    fds: WasiFds;
+    kernel: WasiKernel;
+    now: ClockNow;
+    interruptWakes?: boolean;
+    entered?: boolean;
+}
+export declare function pollOneoff(deps: PollDeps, inPtr: number, outPtr: number, nsubs: number, neventsPtr: number): number;
+export {};

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

@@ -0,0 +1,36 @@
+import type { MountLine, ProcessListing } from '../../kernel/proc-info.js';
+import { type SyncFsBridgeStat, type SyncFsPosixBridge } from '../../realm/sync-fs-wire.js';
+import { type MemorySource } from '../procfs.js';
+export interface ProcSource {
+    procList(): ProcessListing;
+    mountList(): MountLine[];
+}
+export declare function inProc(path: string): boolean;
+export declare class ProcTree {
+    private readonly source;
+    private readonly pid;
+    private readonly memory;
+    constructor(source: ProcSource, pid: number, memory?: MemorySource);
+    private listing;
+    private alive;
+    private node;
+    private info;
+    private task;
+    private parts;
+    private find;
+    stat(path: string, follow?: boolean): SyncFsBridgeStat;
+    private bytes;
+    read(path: string): Uint8Array;
+    readdir(path: string): string[];
+    readlink(path: string): string;
+    exists(path: string): boolean;
+}
+type ProcRefusal = {
+    refused: string;
+};
+export declare function procAlias(fs: {
+    readlink?(path: string): Promise<string>;
+    lstat?(path: string): Promise<unknown>;
+}, path: string, follow: boolean): Promise<string | undefined | ProcRefusal>;
+export declare function procfsBridge<T extends SyncFsPosixBridge>(fs: T, tree: ProcTree): T;
+export {};

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

@@ -0,0 +1,19 @@
+import { type BlockedMask } from '../../realm/sync-sab-wire.js';
+export declare const kernelBits: (lo: number) => number;
+export declare const libcBits: (bits: number) => number;
+export declare class WasiSigmask {
+    private lo;
+    private hi;
+    private readonly header;
+    private readonly deliver;
+    private readonly process;
+    constructor(header: Int32Array, deliver: () => void, process?: Int32Array);
+    static unsupported(header: Int32Array): void;
+    set(how: number, setLo: number, setHi: number, old: (lo: number, hi: number) => void): number;
+    swap(setLo: number, setHi: number): [number, number];
+    deliverUnblocked(): boolean;
+    restore([lo, hi]: [number, number]): void;
+    inherited(): BlockedMask;
+    discard(sig: number): void;
+    pending(): number;
+}

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

@@ -0,0 +1,43 @@
+import type { SignalHooks } from '../process-signals.js';
+export interface WasiSignalState {
+    callback?: string;
+    hooked?: true;
+    handlers: number;
+    ignoring: number;
+    restarting: number;
+    uncaught: number;
+}
+export declare class WasiSignals implements SignalHooks {
+    private exports;
+    private callback;
+    private uncaught;
+    private delivering;
+    private defaulted;
+    private libcDefault;
+    private hooked;
+    private handlers;
+    private ignoring;
+    private restarting;
+    private defaults;
+    private readonly fallBack;
+    private readonly onKilled;
+    constructor(fallBack: (sig: number) => void, onKilled?: (code: number) => void);
+    killed(code: number): void;
+    bind(exports: WebAssembly.Exports): void;
+    register(name: string): void;
+    useHook(): void;
+    disposition(sig: number, disposition: number, flags: number): number;
+    snapshot(): WasiSignalState;
+    restore(state: WasiSignalState): void;
+    masks(): {
+        caught: number;
+        ignored: number;
+        restart: number;
+        defaults?: number;
+    } | null;
+    raise(sig: number): void;
+    muted(fd: number, data: Uint8Array): boolean;
+    raised(sig: number): boolean;
+    private defaultAction;
+    private handler;
+}

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

@@ -0,0 +1,10 @@
+import type { Termios } from '../../kernel/tty.js';
+import type { WasiFds, WasiKernel } from './wasi-fds.js';
+import type { WasiMemory } from './wasi-memory.js';
+export declare function writeTermios(mem: WasiMemory, ptr: number, termios: Termios): void;
+export declare function readTermios(mem: WasiMemory, ptr: number): Termios;
+export declare function sliccTty(mem: WasiMemory, fds: WasiFds, kernel: WasiKernel, interrupted?: () => void): {
+    tcgetattr: (fd: number, ptr: number) => undefined;
+    tcsetattr: (fd: number, actions: number, ptr: number) => undefined;
+    winsize: (fd: number, ptr: number) => undefined;
+};