@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.0

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

@@ -0,0 +1,525 @@
+import { type Created, type Dac } from '../fs/dac.js';
+import type { KernelFs } from '../fs/types.js';
+import type { MountCall } from '../mount/syscall.js';
+import type { LinkRecord } from '../process/wasi/wasix-linker.js';
+import type { SourceCheck } from '../realm/sync-fs-token-registry.js';
+import type { SyncFsResult } from '../realm/sync-fs-wire.js';
+import type { SudoCall, SudoResult } from '../sudo.js';
+import { type ChildForker, type ChildSpawner, type ChildStdio, type InheritedSlot } from './children.js';
+import type { ClipboardBroker } from './clipboard.js';
+import { type Cred, type CredChange } from './cred.js';
+import { type EpollSyscall } from './epoll.js';
+import { type DeviceAccess, type FdTable, type HeldMeta, type KernelFdKind, type OpenFile } from './fd-table.js';
+import { type HostSyscall } from './host-ops.js';
+import type { JobTable } from './jobs.js';
+import type { LockTable } from './locks.js';
+import { type HttpHandles, type HttpSyscall } from './net/http-syscalls.js';
+import { Resolver } from './net/resolver.js';
+import type { MountLine, ProcessListing } from './proc-info.js';
+import type { DlState, ForkState } from './protocol.js';
+import { type PtySyscall, type PtyTable } from './pty.js';
+import { type RunRequest } from './run-child.js';
+import type { SealedBroker, SealedCaller } from './sealed.js';
+import { type SemSyscall, type SemTable } from './sem.js';
+import { type DefaultAction } from './signals.js';
+import { LoopbackNet } from './socket.js';
+import { type SocketSyscall } from './socket-syscalls.js';
+import type { Termios } from './tty.js';
+import { type VersionPin, type VfsFileFs, VfsNodes } from './vfs-file.js';
+export type WasmSyscall = {
+    op: 'fd-read';
+    fd: number;
+    max: number;
+    nonblock?: boolean;
+    peek?: boolean;
+} | {
+    op: 'fd-write';
+    fd: number;
+    body: Uint8Array;
+    nonblock?: boolean;
+} | {
+    op: 'fd-close';
+    fd: number;
+} | {
+    op: 'fd-pipe';
+} | {
+    op: 'fd-poll';
+    fd: number;
+} | {
+    op: 'fd-open-vfs';
+    path: string;
+    flags: number;
+    position: number;
+    mode?: number;
+    contents?: Uint8Array;
+    orphan?: boolean;
+    truncate?: boolean;
+    create?: boolean;
+    exclusive?: boolean;
+    created?: boolean;
+    existing?: boolean;
+    pin?: VersionPin;
+    handle?: number;
+} | {
+    op: 'fd-pread';
+    fd: number;
+    offset: number;
+    max: number;
+} | {
+    op: 'fd-pwrite';
+    fd: number;
+    offset: number;
+    body: Uint8Array;
+} | {
+    op: 'fd-resize';
+    fd: number;
+    size: number;
+} | {
+    op: 'fd-vfs-stat';
+    fd: number;
+    identity?: boolean;
+    full?: boolean;
+} | {
+    op: 'fd-chmod';
+    fd: number;
+    mode: number;
+} | {
+    op: 'fd-chown';
+    fd: number;
+    uid?: number;
+    gid?: number;
+} | {
+    op: 'fd-utimes';
+    fd: number;
+    atimeMs: number | null;
+    mtimeMs: number | null;
+    now?: boolean;
+} | {
+    op: 'fd-path-flush';
+    path: string;
+} | {
+    op: 'fd-path-unlinking';
+    path: string;
+} | {
+    op: 'fd-path-unlinked';
+    path: string;
+} | {
+    op: 'fd-path-renamed';
+    from: string;
+    to: string;
+} | {
+    op: 'fd-seek';
+    fd: number;
+    offset: number;
+    whence: number;
+} | {
+    op: 'fd-select';
+    read: number[];
+    write: number[];
+    timeoutMs: number;
+} | {
+    op: 'fd-info';
+    fd: number;
+} | {
+    op: 'fd-dup';
+    fd: number;
+    min?: number;
+} | {
+    op: 'fd-reserve';
+    fd?: number;
+    min?: number;
+    meta?: HeldMeta;
+} | {
+    op: 'fd-meta';
+    fd: number;
+    meta: HeldMeta;
+} | {
+    op: 'fd-setfl';
+    fd: number;
+    flags: number;
+} | {
+    op: 'fd-cloexec';
+    fd: number;
+    on: boolean;
+} | {
+    op: 'fd-list';
+} | {
+    op: 'dl-log';
+    append?: LinkRecord;
+    from: number;
+} | {
+    op: 'dl-closure';
+    floor: number;
+} | {
+    op: 'dl-reserve';
+    floor: number;
+    size: number;
+} | {
+    op: 'dl-load-reserve';
+    floor: number;
+    size: number;
+} | {
+    op: 'dl-lock';
+    owner: number;
+} | {
+    op: 'dl-unlock';
+    owner: number;
+} | {
+    op: 'dl-closure-free';
+    index: number;
+} | {
+    op: 'proc-alarm';
+    sig: number;
+    ms: number;
+    firstMs?: number;
+    repeat: boolean;
+    timer?: number;
+} | {
+    op: 'fd-renumber';
+    from: number;
+    to: number;
+    keep?: boolean;
+} | {
+    op: 'proc-umask';
+    mask?: number;
+} | {
+    op: 'proc-cred';
+} | {
+    op: 'proc-setcred';
+    change: CredChange;
+} | {
+    op: 'fd-promote';
+    fd: number;
+    share?: number;
+    path?: string;
+    flags?: number;
+    position?: number;
+    contents?: Uint8Array;
+    orphan?: boolean;
+    dirty?: boolean;
+    pin?: VersionPin;
+    handle?: number;
+} | {
+    op: 'fd-open-tty';
+    name?: string;
+} | {
+    op: 'fd-tty-names';
+} | {
+    op: 'fd-tty-owner';
+    name: string;
+} | {
+    op: 'fd-open-sealed';
+    flags: number;
+} | {
+    op: 'fd-open-clipboard';
+    flags: number;
+} | {
+    op: 'fd-clipboard-abort';
+    fd: number;
+} | {
+    op: 'tty-get';
+    fd: number;
+} | {
+    op: 'tty-set';
+    fd: number;
+    termios: Termios;
+    flush?: boolean;
+} | {
+    op: 'tty-winsz';
+    fd: number;
+} | {
+    op: 'fd-flush';
+    fd: number;
+} | {
+    op: 'proc-spawn';
+    file: string;
+    argv: string[];
+    argv0?: string;
+    env: Record<string, string>;
+    cwd: string;
+    stdio: ChildStdio[];
+    pgid?: number;
+    session?: true;
+    deathSignal?: number;
+    inherit?: InheritedSlot[];
+    exec?: boolean;
+    restart?: true;
+} | {
+    op: 'proc-wait';
+    pid: number;
+    nohang: boolean;
+    untraced?: boolean;
+    continued?: boolean;
+} | {
+    op: 'proc-captured';
+    pid: number;
+    slot: number;
+} | SudoCall | RunRequest | {
+    op: 'proc-exit';
+    status: number;
+} | {
+    op: 'proc-kill-self';
+    sig: number;
+    target?: number;
+    probe?: boolean;
+} | {
+    op: 'proc-fork';
+    state: ForkState;
+    restart?: true;
+} | {
+    op: 'proc-kill';
+    pid: number;
+    sig: number;
+} | {
+    op: 'thread-kill';
+    tid: number;
+    sig: number;
+} | {
+    op: 'proc-list';
+} | {
+    op: 'mount-list';
+} | ({
+    op: 'mount';
+} & MountCall) | {
+    op: 'umount';
+    target: string;
+    flags: number;
+} | {
+    op: 'proc-exec';
+    pid: number;
+} | {
+    op: 'proc-identity';
+} | {
+    op: 'proc-setpgid';
+    pid: number;
+    pgid: number;
+} | {
+    op: 'proc-getpgid';
+    pid: number;
+} | {
+    op: 'proc-getsid';
+    pid: number;
+} | {
+    op: 'proc-setsid';
+} | {
+    op: 'tty-pgrp-get';
+    fd: number;
+} | {
+    op: 'tty-pgrp-set';
+    fd: number;
+    pgrp: number;
+} | {
+    op: 'sig-mask';
+    caught: number;
+    ignored: number;
+    defaults?: number;
+} | {
+    op: 'sig-pause';
+} | SocketSyscall | EpollSyscall | SemSyscall | HttpSyscall | PtySyscall | HostSyscall;
+export interface FdInfo {
+    tty: boolean;
+    kind: KernelFdKind;
+    dgram?: true;
+    meta?: HeldMeta;
+    flags?: number;
+    cloexec?: true;
+    access?: DeviceAccess;
+    name?: string;
+    terminal?: string;
+}
+export declare function isWasmSyscall(req: object): req is WasmSyscall;
+export declare const DEFAULT_UMASK = 18;
+export interface WasmProcessOptions {
+    ignored?: number;
+    source?: SourceCheck;
+    umask?: number;
+    cred?: Cred;
+    owners?: boolean;
+    sealed?: SealedBroker;
+    outputFilter?: (file: OpenFile) => OpenFile;
+    clipboard?: ClipboardBroker;
+    clipboardName?: string;
+    readonlyAt?: (path: string) => boolean;
+    guard?: {
+        dac: Dac;
+        fs: KernelFs;
+        created?: Created;
+        links?: number;
+    };
+    noLinks?: KernelFs;
+    identity?: () => Promise<{
+        pid: number;
+        ppid: number;
+    }>;
+    onSyscall?: (req: WasmSyscall) => void;
+    spawner?: ChildSpawner;
+    forker?: ChildForker;
+    fs: VfsFileFs;
+    kill?: (pid: number, sig: number) => boolean | Promise<boolean>;
+    writesBack?: (pid: number) => boolean;
+    processes?: () => ProcessListing;
+    sudo?: (call: SudoCall, signal: AbortSignal) => Promise<SudoResult>;
+    openFiles?: Set<VfsNodes>;
+    nodes?: VfsNodes;
+    mounts?: () => MountLine[];
+    mount?: (call: MountCall, signal: AbortSignal) => Promise<unknown>;
+    umount?: (target: string, flags: number) => Promise<void>;
+    onPending?: (sig: number) => void;
+    onTimer?: (which: number) => void;
+    onAsync?: () => void;
+    hasPending?: () => boolean;
+    threadKill?: (tid: number, sig: number) => boolean;
+    unblockedThread?: (sig: number) => number | undefined;
+    settling?: () => boolean;
+    pendingBits?: () => number;
+    blockedBits?: () => number;
+    dl?: DlState;
+    raise?: (sig: number) => void;
+    exitNow?: (status: number) => void;
+    exitSignal?: (sig: number) => void;
+    onReap?: (pid: number) => void;
+    jobs?: JobTable;
+    ptys?: PtyTable;
+    net?: LoopbackNet;
+    http?: HttpHandles;
+    locks?: LockTable;
+    sems?: SemTable;
+    resolver?: Resolver;
+}
+export type StateListener = (state: 'stopped' | 'continued', sig: number) => void;
+export type SignalOutcome = DefaultAction | 'deliver' | 'forward';
+export declare class WasmProcess {
+    private exited;
+    private readonly children;
+    private readonly deathSignals;
+    private caught;
+    private ignored;
+    private inherited;
+    private interrupt;
+    private readonly gone;
+    private dying;
+    umask: number;
+    cred: Cred;
+    private execChild;
+    private killed;
+    execTermsig: number | undefined;
+    private stopped;
+    private stops;
+    private owed;
+    private readonly waiting;
+    private resumed;
+    private wake;
+    private readonly stateListeners;
+    private net;
+    private readonly nodes;
+    readonly pid: number;
+    readonly fds: FdTable;
+    private readonly options;
+    constructor(pid: number, fds: FdTable, options: WasmProcessOptions);
+    private ignores;
+    signalMasks(): {
+        ignored: number;
+        caught: number;
+    };
+    inheritable(fork?: boolean): number;
+    signal(sig: number): SignalOutcome;
+    private spawn;
+    private onDeath;
+    private sendDeath;
+    private killSelf;
+    private run;
+    private adoptExec;
+    onState(listener: StateListener): void;
+    private stop;
+    private cont;
+    private readonly blocks;
+    private readonly sizesRead;
+    syscall(req: WasmSyscall, cancelled?: AbortSignal, block?: () => void): Promise<SyncFsResult>;
+    setUmask(mask?: number): number;
+    die(): void;
+    private dispatch;
+    private readonly lockOwners;
+    private readonly lockChecked;
+    private lockOwner;
+    private readonly pathKeys;
+    private lockPath;
+    private lockKey;
+    private dropRecordLocks;
+    private refuseIfPending;
+    private procWait;
+    private blockingSignal;
+    private cancelSignal;
+    private read;
+    private readClipboard;
+    private clipboardComplaint;
+    private write;
+    private openVfs;
+    private openDevice;
+    private identified;
+    private writesAt;
+    private sourceOpen;
+    private markedPath;
+    private openPath;
+    private mayOpen;
+    private openTty;
+    private openSealed;
+    private openClipboard;
+    private clipboardStamp;
+    private stampClipboards;
+    connectorStamp(): Promise<SealedCaller>;
+    private sealedCaller;
+    private guarded;
+    private ttyOwner;
+    private terminalByName;
+    private plainMode;
+    private newOwner;
+    private openProc;
+    private procFile;
+    private openVfsFile;
+    private fdSyscall;
+    private vfsSyscall;
+    keptPath?: (path: string) => string | undefined;
+    holds(path: string): Promise<boolean>;
+    keptHandle?: (handle: number) => string | undefined;
+    private keptOr;
+    private promote;
+    private reserve;
+    private heldPath;
+    private heldFs;
+    private heldStat;
+    private fdMetadata;
+    private fdInfo;
+    private ttySyscall;
+    private checkForeground;
+    private waitGroup;
+    private pgid;
+    private sid;
+    private controllingTerminal;
+    private jobSyscall;
+    private httpSyscall;
+    private semSyscall;
+    private socketSyscall;
+    private tty;
+    private procSyscall;
+    private sudo;
+    private mountSyscall;
+    private pause;
+    private alarm;
+    private readonly dlLog;
+    private readonly closures;
+    private withDl;
+    private seedDl;
+    private allocateClosure;
+    private freeClosure;
+    private readonly dlLock;
+    private lockDl;
+    threadEnded(tid: number): void;
+    private unlockDl;
+    private wakeDl;
+    private reserveSlots;
+    private readonly asyncOps;
+    private setAlarm;
+    private timerExpired;
+    private clearAlarm;
+    exit(): Promise<void>;
+}

package/dist/types/kernel/protocol.d.ts

@@ -0,0 +1,126 @@
+import type { ForeignResults, ImportedMemory } from '../process/wasi/wasi-module.js';
+import type { WasiForkState } from '../process/wasi/wasix-fork.js';
+import type { LinkRecord } from '../process/wasi/wasix-linker.js';
+import type { BlockedMask } from '../realm/sync-sab-wire.js';
+import type { Cred } from './cred.js';
+import type { DeviceMeta, KernelFdKind } from './fd-table.js';
+export declare const WASM_PROCESS_INIT = "wasm-process-init";
+export declare const WASM_PROCESS_EXIT = "wasm-process-exit";
+export declare const WASM_PROCESS_ERROR = "wasm-process-error";
+export declare const WASM_THREAD_SPAWN = "wasm-thread-spawn";
+export declare const WASM_THREAD_INIT = "wasm-thread-init";
+export declare const WASM_THREAD_EXIT = "wasm-thread-exit";
+export declare const WASM_MAX_THREADS = 256;
+export declare const WASM_DEFAULT_THREADS = 64;
+export interface WasmProgram {
+    abi?: 'emscripten' | 'wasi';
+    glue: string;
+    module: WebAssembly.Module;
+    memory?: ImportedMemory;
+    foreign?: ForeignResults | undefined;
+    path?: string;
+    names?: string;
+    imports?: string;
+    preopenRoot?: boolean;
+}
+export interface JsProgram {
+    abi: 'js';
+    glue: string;
+    path: string;
+}
+export type Program = WasmProgram | JsProgram;
+export interface ForkState {
+    memory: Uint8Array;
+    currData: number;
+    forkSp: number;
+    callStackNames: Array<[number, string]>;
+    ppid: number;
+    streams?: ForkStream[];
+    cwd?: string;
+    wasi?: WasiForkState;
+    dl?: DlState;
+}
+export interface DlState {
+    log: LinkRecord[];
+    next: number;
+    handle: number;
+    free: number[];
+    live: number[];
+}
+export interface KernelStreamEntry {
+    fd: number;
+    kernel: number;
+    kind: KernelFdKind;
+    flags?: number;
+    cloexec?: boolean;
+    desc?: number;
+}
+export type ForkStream = KernelStreamEntry | {
+    fd: number;
+    path: string;
+    flags: number;
+};
+export interface InheritedFd {
+    fd: number;
+    kind: KernelFdKind;
+    device?: DeviceMeta;
+    flags?: number;
+    cloexec?: boolean;
+    desc?: number;
+}
+export interface WasmProcessInitMsg {
+    type: typeof WASM_PROCESS_INIT;
+    pid: number;
+    program: WasmProgram;
+    argv0: string;
+    args: string[];
+    env: Record<string, string>;
+    cwd: string;
+    sab: SharedArrayBuffer;
+    changes?: SharedArrayBuffer;
+    ppid?: number;
+    umask?: number;
+    cred?: Cred;
+    owners?: boolean;
+    links?: boolean;
+    fork?: ForkState;
+    fds?: InheritedFd[];
+}
+export interface JsLane {
+    sab: SharedArrayBuffer;
+    port: MessagePort;
+}
+export type JsProcessInitMsg = Omit<WasmProcessInitMsg, 'program' | 'fork'> & {
+    program: JsProgram;
+    lane?: JsLane;
+};
+export type ProcessInitMsg = WasmProcessInitMsg | JsProcessInitMsg;
+export interface WasmProcessExitMsg {
+    type: typeof WASM_PROCESS_EXIT;
+    code: number;
+}
+export interface WasmProcessErrorMsg {
+    type: typeof WASM_PROCESS_ERROR;
+    message: string;
+    code?: number;
+}
+export interface WasmThread {
+    tid: number;
+    arg: number;
+    memory: WebAssembly.Memory;
+    ids: SharedArrayBuffer;
+    modules?: Record<string, WebAssembly.Module>;
+    blocked?: BlockedMask;
+}
+export interface WasmThreadSpawnMsg {
+    type: typeof WASM_THREAD_SPAWN;
+    thread: WasmThread;
+}
+export interface WasmThreadInitMsg extends Omit<WasmProcessInitMsg, 'type' | 'fork' | 'fds'> {
+    type: typeof WASM_THREAD_INIT;
+    thread: WasmThread;
+    signals?: SharedArrayBuffer;
+}
+export interface WasmThreadExitMsg {
+    type: typeof WASM_THREAD_EXIT;
+}