@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.0

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

package/dist/types/process/wasi/wasix-fork.d.ts

@@ -0,0 +1,63 @@
+import type { BlockedMask } from '../../realm/sync-sab-wire.js';
+import type { WasiForkFd } from './wasi-fds.js';
+import type { WasiMemory } from './wasi-memory.js';
+import type { WasiSignalState } from './wasi-signals.js';
+export interface WasiForkState {
+    asyncifyData: number;
+    globals: Array<[string, number]>;
+    fds: WasiForkFd[];
+    cloexec: number[];
+    cwd: string;
+    shared?: true;
+    setjmps?: WasiSetjmps;
+    signals?: WasiSignalState;
+    blocked?: BlockedMask;
+    tls?: Array<[number, number]>;
+    modules?: Record<string, WebAssembly.Module>;
+    entry?: ThreadEntry;
+}
+export interface ThreadEntry {
+    tid: number;
+    arg: number;
+    low: number;
+}
+export interface WasiSetjmps {
+    next: number;
+    snapshots: Array<[number, Snapshot]>;
+}
+interface Snapshot {
+    frames: Uint8Array;
+    globals: Array<[string, number]>;
+}
+export declare function reseatTls(exports: WebAssembly.Exports, bytes: (at: number, length: number) => Uint8Array): void;
+export declare class AsyncifyDriver {
+    private exports;
+    private stackUpper;
+    private linked;
+    private pending;
+    private answer;
+    private readonly snapshots;
+    private nextSnapshot;
+    private readonly mem;
+    constructor(mem: WasiMemory);
+    useStack(pointer: WebAssembly.Global, low: number): void;
+    private threadStack;
+    useThreadStack(pointer: WebAssembly.Global, low: number): void;
+    bind(exports: WebAssembly.Exports): void;
+    get supported(): boolean;
+    get idle(): boolean;
+    resume(): boolean;
+    setjmps(): WasiSetjmps;
+    startChild(state: WasiForkState): void;
+    rewound(): number | undefined;
+    fork(fork: (asyncifyData: number, globals: Array<[string, number]>, sp: number) => number): number;
+    checkpoint(snapPtr: number, retPtr: number): number;
+    restore(snapPtr: number, val: bigint): number;
+    private stackGlobal;
+    private stackPointer;
+    private globals;
+    private dataPointer;
+    private unwind;
+    private restoreGlobals;
+}
+export {};

package/dist/types/process/wasi/wasix-linker.d.ts

@@ -0,0 +1,108 @@
+import { type DylinkInfo } from './dylink.js';
+import { type Scalar, Trampolines } from './wasix-trampoline.js';
+import { FuncTypes } from './wasm-functypes.js';
+export declare const TABLE_BASE = 1;
+export declare const STACK_SIZE: number;
+export type LinkRecord = {
+    kind: 'load';
+    handle: number;
+    path: string;
+    memoryBase: number;
+    tableBase: number;
+    needed?: number[];
+} | {
+    kind: 'slot';
+    index: number;
+    handle: number;
+    name: string;
+} | {
+    kind: 'closure';
+    index: number;
+} | {
+    kind: 'closure-free';
+    index: number;
+} | {
+    kind: 'closure-prepare';
+    index: number;
+    backing: number;
+    userData: number;
+    params: Scalar[];
+    results: Scalar[];
+};
+export interface LinkerHost {
+    read(path: string): Uint8Array<ArrayBuffer> | undefined;
+    hostImports(module: WebAssembly.Module): WebAssembly.Imports;
+    real?(path: string): string;
+}
+export declare class DlError extends Error {
+}
+export declare class WasixLinker {
+    readonly table: WebAssembly.Table;
+    readonly stackPointer: WebAssembly.Global;
+    readonly memoryBase: number;
+    readonly stackLow: number;
+    readonly stackHigh: number;
+    private readonly cLongjmp;
+    private readonly cppException;
+    private main;
+    private readonly modules;
+    forkedTls: Map<number, number> | undefined;
+    private readonly byPath;
+    private mainGot;
+    private readonly slots;
+    private nextHandle;
+    publisher: ((record: LinkRecord) => void) | undefined;
+    indices: {
+        reserve(floor: number, size: number): number;
+        load(floor: number, size: number): {
+            base: number;
+            handle: number;
+        };
+        lock(): void;
+        unlock(): void;
+        allocate(floor: number): number;
+        free(index: number): void;
+    } | undefined;
+    types: FuncTypes;
+    readonly trampolines: Trampolines;
+    private readonly memory;
+    private readonly host;
+    constructor(memory: WebAssembly.Memory, mainInfo: DylinkInfo, host: LinkerHost, thread?: boolean);
+    mainImports(module: WebAssembly.Module): Record<string, Record<string, WebAssembly.ImportValue>>;
+    bindMainGot(): void;
+    bindMain(instance: WebAssembly.Instance, relocate: boolean): void;
+    mainPath: string | undefined;
+    private isMain;
+    open(name: string, cwd: string, ldPath: readonly string[]): number;
+    symbol(handle: number, name: string): number;
+    invalid(handle: number): boolean;
+    cache: Readonly<Record<string, WebAssembly.Module>> | undefined;
+    compiled(): Record<string, WebAssembly.Module>;
+    allocateClosure(): number;
+    freeClosure(index: number): void;
+    private readonly live;
+    prepareClosure(record: Omit<Extract<LinkRecord, {
+        kind: 'closure-prepare';
+    }>, 'kind'>): void;
+    private install;
+    private reserveLoad;
+    private reserve;
+    tlsBases(): Array<[number, number]>;
+    private carryTls;
+    replay(record: LinkRecord): void;
+    private moduleAt;
+    private module;
+    private locate;
+    private load;
+    private instantiate;
+    private functionImport;
+    private addressOrNull;
+    private slotOrNull;
+    private find;
+    private findIn;
+    private baseOf;
+    private indexed;
+    private indexTable;
+    private slot;
+    private allocate;
+}

package/dist/types/process/wasi/wasix-sockets.d.ts

@@ -0,0 +1,9 @@
+import type { SockAddr } from '../../kernel/socket.js';
+import type { WasiFunction, WasiHost } from './wasi-host.js';
+export declare function readAddr(view: DataView, ptr: number): SockAddr;
+export declare function writeAddr(view: DataView, ptr: number, addr: SockAddr | undefined): void;
+export declare function datagramCalls(host: WasiHost): {
+    recvFrom(fd: number, nonblock: boolean, iovs: number, n: number, riflags: number, outLen: number, outFlags: number, outAddr: number): number;
+    sendTo(fd: number, nonblock: boolean, iovs: number, n: number, addr: number, out: number): 0;
+};
+export declare function wasixSocketImports(host: WasiHost, preview1: Record<string, WasiFunction>): Record<string, WasiFunction>;