@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.1

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

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

@@ -0,0 +1,84 @@
+import { type Guard } from '../fs/dac.js';
+import type { Perm } from '../fs/types.js';
+import type { SyncFsResult } from '../realm/sync-fs-wire.js';
+import { type FdTable, OpenFile } from './fd-table.js';
+import type { JobTable } from './jobs.js';
+import { KernelTty } from './tty.js';
+export type PtySignal = (tty: KernelTty, sig: number) => void;
+export declare class PtyPair {
+    readonly slave: KernelTty;
+    locked: boolean;
+    packet: boolean;
+    private queue;
+    private waiters;
+    private masterOpen;
+    private slaveRefs;
+    private slaveSeen;
+    readonly index: number;
+    private readonly onFree;
+    constructor(index: number, signal: PtySignal, onFree: (pair: PtyPair) => void, onRead?: (tty: KernelTty) => void);
+    master(): OpenFile;
+    openSlave(): OpenFile;
+    private get slaveGone();
+    private fromSlave;
+    private readMaster;
+    private closeMaster;
+    private closeSlave;
+    private freeIfUnused;
+    private changed;
+    private wake;
+}
+export declare class PtyTable {
+    private readonly pairs;
+    private readonly signal;
+    private readonly onRead;
+    constructor(signal: PtySignal, onRead?: (tty: KernelTty) => void);
+    open(owner?: Perm): {
+        pair: PtyPair;
+        master: OpenFile;
+    };
+    get(index: number): PtyPair;
+    numbers(): number[];
+}
+export declare function ptsNumber(path: string): number | undefined;
+export type PtySyscall = {
+    op: 'pty-open';
+} | {
+    op: 'pty-slave-open';
+    n: number;
+    noctty: boolean;
+} | {
+    op: 'pty-number';
+    fd: number;
+} | {
+    op: 'pty-lock';
+    fd: number;
+    lock: boolean;
+} | {
+    op: 'pty-ctty';
+    fd: number;
+} | {
+    op: 'pty-packet';
+    fd: number;
+    on: boolean;
+} | {
+    op: 'pty-list';
+} | {
+    op: 'pty-winsz-set';
+    fd: number;
+    rows: number;
+    cols: number;
+};
+export declare const PTY_OPS: readonly PtySyscall['op'][];
+export interface PtyContext {
+    pid: number;
+    fds: FdTable;
+    ptys?: PtyTable;
+    jobs?: JobTable;
+    guard?: Guard;
+    owner?: Perm;
+    outputFilter?: (file: OpenFile) => OpenFile;
+    sizesRead?: WeakMap<KernelTty, string>;
+}
+export declare function sizeKey(rows: number, cols: number): string;
+export declare function ptySyscall(req: PtySyscall, ctx: PtyContext): SyncFsResult;

package/dist/types/kernel/run-child.d.ts

@@ -0,0 +1,39 @@
+import { type ChildTable } from './children.js';
+export type RunStdio = 'pipe' | 'ignore' | 'inherit' | number;
+export type RunStderr = RunStdio | 'stdout';
+export interface RunRequest {
+    op: 'proc-run';
+    file: string;
+    argv: string[];
+    argv0?: string;
+    env: Record<string, string>;
+    cwd: string;
+    pgid?: number;
+    session?: true;
+    stdin: RunStdio;
+    input?: Uint8Array;
+    stdout: RunStdio;
+    stderr: RunStderr;
+    maxBuffer?: number;
+    timeoutMs?: number;
+    killSignal: number;
+}
+export interface RunOutcome {
+    pid: number;
+    status: number | null;
+    signal?: number;
+    error?: {
+        code: string;
+    };
+    out: number;
+    err: number;
+}
+export declare const RUN_CAPTURE_CAP: number;
+export declare const RUN_MAX_BUFFER: number;
+export interface RunDeps {
+    children: ChildTable;
+    kill(pid: number, sig: number): Promise<unknown> | unknown;
+    interrupt(): AbortSignal;
+    dying(): boolean;
+}
+export declare function runChild(req: RunRequest, deps: RunDeps): Promise<Uint8Array>;

package/dist/types/kernel/scrub-file.d.ts

@@ -0,0 +1,13 @@
+import { type Scrubber } from '@ai-ecoverse/slicc-scrub';
+import { type FdTable, OpenFile } from './fd-table.js';
+export declare const SCRUB_IDLE_MS = 50;
+export declare const SCRUB_NONBLOCK_MAX: number;
+export interface ScrubSecret {
+    name: string;
+    value: string;
+    placeholder: string;
+}
+export declare function scrubberOf(secrets: ScrubSecret[]): Scrubber | undefined;
+export declare function scrubbed(inner: OpenFile, scrubber: Scrubber, idleMs?: number): OpenFile;
+export declare function scrubbedAll(file: OpenFile, scrubbers: readonly Scrubber[]): OpenFile;
+export declare function scrubStdio(fds: FdTable, scrubber: Scrubber): void;

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

@@ -0,0 +1,74 @@
+import type { UsersMode } from '../fs/types.js';
+import type { Cred } from './cred.js';
+import { TicketBook } from './exec-ticket.js';
+import { type OpenAccess, OpenFile, type PollState } from './fd-table.js';
+export declare const SEALED_PATH = "/dev/sealed";
+export declare const SEALED_MAX_BYTES: number;
+export declare const SEALED_TIMEOUT_MS = 10000;
+export declare const SEALED_OPS: ReadonlySet<string>;
+export interface SealedCaller {
+    pid: number;
+    ppid: number;
+    uid: number;
+    gid: number;
+    user?: string;
+    groups: number[];
+    users: UsersMode;
+    tag?: string;
+}
+export type SealedRequest = {
+    v: 1;
+    op: string;
+    caller: SealedCaller;
+} & Record<string, unknown>;
+export type SealedHook = (req: SealedRequest, options: {
+    signal: AbortSignal;
+}) => Promise<object>;
+export type SealedAbortReason = 'replaced' | 'timeout' | 'withdrawn';
+export declare function parseSealed(bytes: Uint8Array): Record<string, unknown>;
+declare class SealedChannel {
+    private reply;
+    private offset;
+    private inflight;
+    private readonly broker;
+    readonly access: OpenAccess;
+    constructor(broker: SealedBroker, access: OpenAccess);
+    send(bytes: Uint8Array, caller: SealedCaller, gone: AbortSignal): number;
+    private answer;
+    private drop;
+    read(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    private until;
+    poll(): PollState;
+    changed(signal?: AbortSignal): Promise<void>;
+    close(): void;
+}
+export interface ConsumeFields {
+    ticket: string;
+    stamp: SealedCaller;
+    path: string;
+    resolved: string;
+    argv: string[];
+    cwd: string;
+    interpreters: string[];
+    trusted: boolean;
+}
+export interface Swap {
+    values: Record<string, string>;
+    placeholders: Record<string, string>;
+}
+export declare class SealedBroker {
+    readonly hook: SealedHook | undefined;
+    readonly users: UsersMode;
+    readonly timeoutMs: number;
+    readonly tagOf: (pid: number) => string | undefined;
+    readonly tickets: TicketBook;
+    userOf: (uid: number) => Promise<string | undefined>;
+    constructor(hook: SealedHook | undefined, users: UsersMode, timeoutMs?: number, tagOf?: (pid: number) => string | undefined);
+    stamp(ids: {
+        pid: number;
+        ppid: number;
+    }, cred: Readonly<Cred>, tag: string | undefined): Promise<SealedCaller>;
+    consume(fields: ConsumeFields): Promise<Swap | undefined>;
+    open(access?: OpenAccess): OpenFile;
+}
+export type { SealedChannel };

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

@@ -0,0 +1,7 @@
+import { type FdTable } from './fd-table.js';
+export interface SelectResult {
+    read: number[];
+    write: number[];
+    hangup?: number[];
+}
+export declare function selectFds(fds: FdTable, read: readonly number[], write: readonly number[], timeoutMs: number, interrupt: AbortSignal): Promise<SelectResult>;

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

@@ -0,0 +1,72 @@
+import type { SyncFsResult } from '../realm/sync-fs-wire.js';
+import type { Cred } from './cred.js';
+import { type ForkedHandles } from './fd-table.js';
+export declare const SEM_VALUE_MAX = 2147483647;
+export declare const SEM_NAMES_MAX = 65536;
+export declare const SEM_HANDLES_MAX = 65536;
+export type SemWaitHow = 'block' | 'try' | 'timed';
+export type SemSyscall = {
+    op: 'sem-open';
+    name: string;
+    create: boolean;
+    exclusive: boolean;
+    mode: number;
+    value: number;
+} | {
+    op: 'sem-close';
+    handle: number;
+} | {
+    op: 'sem-unlink';
+    name: string;
+} | {
+    op: 'sem-post';
+    handle: number;
+} | {
+    op: 'sem-wait';
+    handle: number;
+    how: SemWaitHow;
+    timeoutMs: number;
+} | {
+    op: 'sem-getvalue';
+    handle: number;
+};
+export declare const SEM_OPS: readonly SemSyscall['op'][];
+export declare class Semaphore {
+    value: number;
+    readonly uid: number;
+    readonly gid: number;
+    readonly mode: number;
+    private readonly waiters;
+    constructor(value: number, uid: number, gid: number, mode: number);
+    post(): void;
+    take(): boolean;
+    wait(signal: AbortSignal, timeoutMs: number): Promise<boolean>;
+}
+export declare class SemTable {
+    private readonly names;
+    private readonly limit;
+    constructor(limit?: number);
+    open(name: string, create: boolean, exclusive: boolean, make: () => Semaphore, check: (s: Semaphore) => void, adopt: (s: Semaphore) => number): number;
+    unlink(name: string, check: (s: Semaphore) => void): void;
+}
+export declare class SemHandles implements ForkedHandles {
+    private readonly byHandle;
+    private next;
+    private readonly limit;
+    constructor(limit?: number);
+    add(sem: Semaphore): number;
+    get(handle: number): Semaphore;
+    close(handle: number): void;
+    fork(): SemHandles;
+    clear(): void;
+}
+export declare function semName(raw: string): string;
+export interface SemProcess {
+    table: SemTable | undefined;
+    handles: SemHandles;
+    cred: Readonly<Cred>;
+    denied: ((op: string, path: string) => void) | undefined;
+    umask: number;
+    blocking(): AbortSignal;
+}
+export declare function semSyscall(req: SemSyscall, proc: SemProcess): Promise<SyncFsResult>;

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

@@ -0,0 +1,16 @@
+export declare const SETTLE_MS = 2000;
+export declare class SettlingChildren {
+    private readonly children;
+    private held;
+    private parked;
+    private readonly pgidOf;
+    private readonly settleMs;
+    constructor(pgidOf: (pid: number) => number | undefined, settleMs?: number);
+    started(pid: number, ppid: number): void;
+    reading(pgid: number): void;
+    isSettling(pid: number): boolean;
+    syscall(pid: number, op: string): void;
+    settled(pid: number): void;
+    deliver(sig: number, pgid: number, send: () => void, foreground?: () => number): void;
+    private blocking;
+}

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

@@ -0,0 +1,44 @@
+export declare const SIG: {
+    readonly HUP: 1;
+    readonly INT: 2;
+    readonly QUIT: 3;
+    readonly ILL: 4;
+    readonly TRAP: 5;
+    readonly ABRT: 6;
+    readonly BUS: 7;
+    readonly FPE: 8;
+    readonly KILL: 9;
+    readonly USR1: 10;
+    readonly SEGV: 11;
+    readonly USR2: 12;
+    readonly PIPE: 13;
+    readonly ALRM: 14;
+    readonly TERM: 15;
+    readonly STKFLT: 16;
+    readonly CHLD: 17;
+    readonly CONT: 18;
+    readonly STOP: 19;
+    readonly TSTP: 20;
+    readonly TTIN: 21;
+    readonly TTOU: 22;
+    readonly URG: 23;
+    readonly XCPU: 24;
+    readonly XFSZ: 25;
+    readonly VTALRM: 26;
+    readonly PROF: 27;
+    readonly WINCH: 28;
+    readonly POLL: 29;
+    readonly PWR: 30;
+    readonly SYS: 31;
+};
+export type DefaultAction = 'terminate' | 'ignore' | 'stop' | 'continue';
+export declare function defaultAction(sig: number): DefaultAction;
+export declare function isSignal(sig: number): boolean;
+export declare function sigbit(sig: number): number;
+export declare function signalsIn(mask: number): number[];
+export declare function signalName(sig: number | undefined): string | undefined;
+export declare function quiet<T>(p: Promise<T>): Promise<T>;
+export declare function signalField(sig: number | undefined): {
+    signal?: string;
+};
+export declare const SIGNAL_BY_NAME: Readonly<Record<'SIGINT' | 'SIGTERM' | 'SIGKILL' | 'SIGSTOP' | 'SIGCONT', number>>;

package/dist/types/kernel/socket-nodes.d.ts

@@ -0,0 +1,20 @@
+import { type Guard } from '../fs/dac.js';
+import { type KernelFs, type NewOwner } from '../fs/types.js';
+import type { SockAddr, SocketName } from './socket.js';
+export interface BoundName extends SocketName {
+    remove(): Promise<void>;
+}
+export interface SocketNames {
+    make(path: string): Promise<BoundName>;
+    find(path: string): Promise<SocketName>;
+}
+export type SocketNameFs = Pick<KernelFs, 'stat' | 'lstat' | 'chmod' | 'rm'>;
+export interface SocketNameDeps {
+    fs: SocketNameFs;
+    guard(): Guard | undefined;
+    create(path: string, owner: NewOwner): Promise<void>;
+    owner(): NewOwner;
+    owners: boolean;
+}
+export declare function filePath(addr: SockAddr): string | undefined;
+export declare function socketNames(deps: SocketNameDeps): SocketNames;

package/dist/types/kernel/socket-syscalls.d.ts

@@ -0,0 +1,76 @@
+import type { SyncFsResult } from '../realm/sync-fs-wire.js';
+import { type FdTable } from './fd-table.js';
+import type { ResolveFamily } from './net/uplink.js';
+import { type ConnectorStamp, type LoopbackNet, type PeerCred, type SockAddr, type SocketDomain } from './socket.js';
+import { type SocketNames } from './socket-nodes.js';
+export type SocketSyscall = {
+    op: 'sock-open';
+    domain: SocketDomain;
+    type?: 'stream' | 'dgram';
+} | {
+    op: 'sock-pair';
+    domain: SocketDomain;
+} | {
+    op: 'sock-bind';
+    fd: number;
+    addr: SockAddr;
+} | {
+    op: 'sock-listen';
+    fd: number;
+    backlog: number;
+} | {
+    op: 'sock-accept';
+    fd: number;
+    nonblock: boolean;
+} | {
+    op: 'sock-connect';
+    fd: number;
+    addr: SockAddr;
+    nonblock: boolean;
+} | {
+    op: 'sock-shutdown';
+    fd: number;
+    how: number;
+} | {
+    op: 'sock-name';
+    fd: number;
+    peer: boolean;
+} | {
+    op: 'sock-getopt';
+    fd: number;
+    level: number;
+    name: number;
+} | {
+    op: 'sock-setopt';
+    fd: number;
+    level: number;
+    name: number;
+    value: number;
+} | {
+    op: 'sock-resolve';
+    name: string;
+    family: ResolveFamily;
+} | {
+    op: 'sock-sendto';
+    fd: number;
+    body: Uint8Array;
+    addr?: SockAddr;
+    nonblock: boolean;
+} | {
+    op: 'sock-recvfrom';
+    fd: number;
+    max: number;
+    peek: boolean;
+    nonblock: boolean;
+};
+export declare const SOCKET_OPS: readonly SocketSyscall['op'][];
+export interface SocketProcess {
+    fds: FdTable;
+    net: LoopbackNet;
+    blocking(): AbortSignal;
+    resolve(name: string, family: ResolveFamily, blocking: () => AbortSignal): Promise<string[]>;
+    cred?(): PeerCred;
+    stamp?(): Promise<ConnectorStamp>;
+    names?: SocketNames;
+}
+export declare function socketSyscall(req: SocketSyscall, proc: SocketProcess): Promise<SyncFsResult>;