@ai-ecoverse/slicc-kernel 1.102.5 → 1.103.0

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

@@ -0,0 +1,34 @@
+export type Signer = (tbs: Uint8Array) => Promise<Uint8Array>;
+export declare function tlv(tag: number, ...contents: readonly Uint8Array[]): Uint8Array;
+export declare function integer(magnitude: Uint8Array): Uint8Array;
+export declare function oid(dotted: string): Uint8Array;
+export interface DistinguishedName {
+    commonName: string;
+    organization?: string;
+}
+export declare function children(der: Uint8Array): Uint8Array[];
+export declare function contents(element: Uint8Array): Uint8Array;
+export declare function publicKeyBits(spki: Uint8Array): Uint8Array;
+export declare function keyId(spki: Uint8Array): Promise<Uint8Array>;
+export declare function ecdsaDer(raw: Uint8Array): Uint8Array;
+export declare function randomSerial(): Uint8Array;
+export declare function ipv4(host: string): Uint8Array | undefined;
+export declare function ipv6(host: string): Uint8Array | undefined;
+export interface CertificateRequest {
+    serial: Uint8Array;
+    issuer: DistinguishedName;
+    subject: DistinguishedName;
+    notBefore: Date;
+    notAfter: Date;
+    spki: Uint8Array;
+    issuerSpki: Uint8Array;
+    kind: {
+        ca: true;
+    } | {
+        ca: false;
+        host: string;
+    };
+    sign: Signer;
+}
+export declare function certificate(req: CertificateRequest): Promise<Uint8Array>;
+export declare function pem(der: Uint8Array): string;

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

@@ -0,0 +1,29 @@
+export declare const PIPE_CAPACITY: number;
+export declare class PipeError extends Error {
+    readonly code: 'EPIPE' | 'EINTR';
+    constructor(code: 'EPIPE' | 'EINTR');
+}
+export declare class KernelPipe {
+    private chunks;
+    private size;
+    private readers;
+    private writers;
+    private waiters;
+    readonly capacity: number;
+    constructor(capacity?: number);
+    get buffered(): number;
+    get readReady(): boolean;
+    get writeReady(): boolean;
+    get writersGone(): boolean;
+    get readersGone(): boolean;
+    openRead(): void;
+    openWrite(): void;
+    closeRead(): void;
+    closeWrite(): void;
+    read(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    peek(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    write(bytes: Uint8Array, signal?: AbortSignal): Promise<number>;
+    private take;
+    changed(signal?: AbortSignal): Promise<void>;
+    private wake;
+}

package/dist/types/kernel/proc-info.d.ts

@@ -0,0 +1,44 @@
+import type { Cred } from './cred.js';
+export interface ProcessInfo {
+    pid: number;
+    tid: number;
+    ppid: number;
+    pgid: number;
+    sid: number;
+    argv: string[];
+    tty: string | null;
+    started: number;
+    state: 'S' | 'T' | 'Z';
+    threads?: Array<{
+        tid: number;
+        state: 'R' | 'S';
+    }>;
+    memory: number;
+    utime?: number;
+    stime?: number;
+    cutime?: number;
+    cstime?: number;
+    umask?: number;
+    cred?: Cred;
+    sigIgn?: number;
+    sigCgt?: number;
+    sigBlk?: number;
+    tag?: string;
+}
+export interface MountLine {
+    type: string;
+    source: string;
+    target: string;
+    options: Record<string, string>;
+    state: 'ok' | 'failed' | 'nomedium' | 'pending';
+}
+export interface ProcessListing {
+    boot: number;
+    processes: ProcessInfo[];
+    load?: readonly [number, number, number];
+    cpu?: {
+        utime: number;
+        stime: number;
+        idle: number;
+    };
+}

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