@ai-ecoverse/slicc-kernel 1.102.5 → 1.103.0

package/dist/types/fs/types.d.ts

@@ -0,0 +1,115 @@
+export interface FsStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+    mode: number;
+    mtime: Date;
+    atime: Date;
+    ctime: Date;
+    ino: number;
+    nlink?: number;
+    dev?: number;
+    readonly?: boolean;
+    maxFile?: number;
+    ranged?: boolean;
+    linkable?: boolean;
+    version?: string;
+    uid?: number;
+    gid?: number;
+}
+export type UsersMode = 'off' | 'report' | 'enforce';
+export declare const DEFAULT_USERS: UsersMode;
+export interface Owner {
+    uid: number;
+    gid: number;
+}
+export interface Perm {
+    uid: number;
+    gid: number;
+    mode?: number;
+    link?: string;
+}
+export interface NewOwner extends Owner {
+    mode?: number;
+    parents?: number;
+}
+export interface OwnerChange {
+    uid?: number;
+    gid?: number;
+    follow?: boolean;
+    kind?: 'chown' | 'adopt' | 'new';
+    mode?: number;
+}
+export interface HeldEntry {
+    writeFile: KernelFs['writeFile'];
+    direct: boolean;
+}
+export interface KernelFs {
+    resolvePath(base: string, path: string): string;
+    exclusive?<T>(path: string, run: (held: HeldEntry) => Promise<T>, follow?: boolean): Promise<T>;
+    readFile(path: string): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: Uint8Array | string, owner?: NewOwner): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    readdir(path: string): Promise<string[]>;
+    readdirStat(path: string): Promise<Array<[string, FsStat | null]>>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        owner?: NewOwner;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+        file?: boolean;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    link(from: string, to: string, follow?: boolean): Promise<void>;
+    links?(path: string): boolean;
+    symlink(target: string, path: string, owner?: NewOwner): Promise<void>;
+    readlink(path: string): Promise<string>;
+    realpath?(path: string, follow: boolean): Promise<string>;
+    createExclusive?(path: string, owner?: NewOwner): Promise<void>;
+    chown?(path: string, change: OwnerChange): Promise<void>;
+    trackOwners?(): void;
+    crossings?(mounted: (path: string) => boolean): void;
+    ancestry?(path: string): Promise<Array<Perm | undefined>>;
+    hasOwner?(path: string): Promise<boolean>;
+    chmod(path: string, mode: number): Promise<void>;
+    append?(path: string, bytes: Uint8Array): Promise<number>;
+    utimes(path: string, atime: Date, mtime: Date): Promise<void>;
+    lutimes?(path: string, atime: Date, mtime: Date): Promise<void>;
+    pread?(path: string, offset: number, length: number, version?: string): Promise<Uint8Array>;
+    pwrite?(path: string, offset: number, bytes: Uint8Array, transfer?: boolean): Promise<void>;
+    truncate?(path: string, size: number): Promise<void>;
+    protect?(prefixes: readonly string[], versions?: boolean): void;
+    unguarded?(): KernelFs;
+    noLinks?(): KernelFs;
+    mayChange?(path: string, follow: boolean, whole?: boolean): Promise<void>;
+    readVersioned?(path: string, cached?: boolean): Promise<{
+        bytes: Uint8Array;
+        version: string;
+    }>;
+    version?(path: string, cached?: boolean): Promise<string>;
+}
+export type RangedOps = Required<Pick<KernelFs, 'pread' | 'pwrite' | 'truncate'>>;
+export declare function rangedOps(fs: Partial<RangedOps>): RangedOps | undefined;
+export declare function lutimesOf(fs: KernelFs, path: string, atime: Date, mtime: Date): Promise<void>;
+export declare function mayLink(fs: {
+    links?(path: string): boolean;
+}, path: string): boolean;
+export declare function modeOption(mode: unknown): number;
+export declare function fsError(code: string, path: string): Error & {
+    code: string;
+};
+export declare function normalizePath(path: string): string;
+export declare function resolvePath(base: string, path: string): string;
+export declare function inodeOf(path: string): number;
+export interface Redirect {
+    of: string;
+    to: string;
+}
+export declare function redirected(of: string, to: string): Error;
+export declare function redirectOf(err: unknown): Redirect | undefined;

package/dist/types/fs/unlinked.d.ts

@@ -0,0 +1,75 @@
+import { type KernelFs, type NewOwner } from './types.js';
+export declare const UNLINKED_DIR = ".slicc-unlinked";
+export interface KeptFile {
+    readonly hidden: string;
+    release(): void;
+}
+export interface UnlinkHolder {
+    held(): Iterable<string>;
+    owns(path: string): boolean;
+    isKept(path: string): boolean;
+    keep(path: string, file: KeptFile): void;
+    unkeep(path: string, file: KeptFile): void;
+}
+export interface UnlinkOwner {
+    readonly id: string;
+    alive(id: string): boolean;
+}
+export interface UnlinkLocks {
+    request(name: string, callback: () => Promise<unknown>): Promise<unknown>;
+    query?(): Promise<{
+        held?: Array<{
+            name?: string;
+        }>;
+    }>;
+}
+export declare function pidOwner(proc: {
+    pid: number;
+    kill(pid: number, signal: number): unknown;
+}): UnlinkOwner;
+export declare function webLocks(): UnlinkLocks | undefined;
+export declare class PathGate {
+    private readonly tails;
+    acquire(path: string): Promise<() => void>;
+    run<T>(path: string, op: () => Promise<T>): Promise<T>;
+}
+interface Pinned {
+    moved: Set<string>;
+    commit(): void;
+    rollback(): Promise<void>;
+}
+export declare class UnlinkedKeeper {
+    private readonly fs;
+    private readonly holders;
+    private readonly rootOf;
+    private readonly locks;
+    private readonly busy;
+    private readonly waiting;
+    private readonly owner;
+    private readonly instance;
+    readonly gate: PathGate;
+    private queue;
+    private count;
+    private readonly links;
+    private readonly linked;
+    private readonly dirOwner;
+    constructor(fs: KernelFs, holders: Iterable<UnlinkHolder>, rootOf: (path: string) => string, options?: {
+        locks?: UnlinkLocks | undefined;
+        busy?: (path: string) => boolean;
+        owner?: UnlinkOwner | undefined;
+        dirOwner?: NewOwner;
+    });
+    private serial;
+    wrap(fs?: KernelFs): KernelFs;
+    settle(pinned: Pinned, op: () => Promise<void>): Promise<void>;
+    pin(target: string): Promise<Pinned>;
+    private keptFile;
+    private hide;
+    closed(path: string): void;
+    private drop;
+    private linkedName;
+    private unlinkedName;
+    private tidy;
+    sweep(root: string): Promise<void>;
+}
+export {};

package/dist/types/fs/view.d.ts

@@ -0,0 +1 @@
+export declare function view<T extends object>(target: T, overrides: Record<string, unknown>): T;

package/dist/types/fs/walk.d.ts

@@ -0,0 +1,12 @@
+export interface LinkReader {
+    readlink?(path: string): Promise<string>;
+    lstat?(path: string): Promise<unknown>;
+}
+export declare function parentOf(path: string): string;
+interface Budget {
+    hops: number;
+}
+export declare function realDir(fs: LinkReader, dir: string, budget?: Budget): Promise<string>;
+export declare function joinName(dir: string, name: string): string;
+export declare function realTarget(fs: LinkReader, path: string): Promise<string>;
+export {};

package/dist/types/fs/watch.d.ts

@@ -0,0 +1,23 @@
+import { type KernelFs } from './types.js';
+export type WatchChange = {
+    paths: string[];
+} | {
+    overflow: true;
+};
+export interface WatchOptions {
+    recursive?: boolean;
+}
+export declare const WATCH_BATCH_LIMIT = 1000;
+export declare class FsWatchers {
+    private readonly watchers;
+    private readonly taps;
+    private readonly reals;
+    private readonly reshapes;
+    onReshape(listener: () => void): void;
+    reshaped(): void;
+    tap(listener: (paths: string[]) => void): void;
+    watch(paths: string[], options: WatchOptions, notify: (change: WatchChange) => void): () => void;
+    changed(...paths: string[]): void;
+    private flush;
+    wrap(fs: KernelFs): KernelFs;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,159 @@
+import type { CdpHook } from './cdp/types.js';
+import { type DialledSocket, type DialOptions } from './client/dial-stream.js';
+import { type LoopbackFetchOptions } from './client/loopback-fetch.js';
+import type { FacadeSpecs } from './facade/types.js';
+import type { Attestation } from './fs/attest.js';
+import type { DenialHook } from './fs/dac.js';
+import { type Protection } from './fs/protect.js';
+import { type UsersMode } from './fs/types.js';
+import type { ClipboardHook } from './kernel/clipboard.js';
+import type { RouteTable } from './kernel/net/routes.js';
+import { type NetworkUplink } from './kernel/net/uplink.js';
+import type { SealedHook } from './kernel/sealed.js';
+import type { HostfsGrantHook } from './mount/hostfs.js';
+import type { MountEntry, MountSpec } from './mount/mount-fs.js';
+import type { ProcessMountPolicy } from './mount/syscall.js';
+import type { ApproveHook } from './sudo.js';
+import { type NetworkTransport } from './transport.js';
+import type { Account, AddUser, Group, RemoveUser } from './users.js';
+export type { CdpConnection, CdpHook, CdpRequest } from './cdp/types.js';
+export { type AttachOptions, attachKernel, type ClientEnded, type ClientFetchRequest, type ClientFs, type ClientRunOptions, type ClientRunResult, type ClientTerminal, type ClientTerminalOptions, KernelCallError, type KernelClient, KernelGoneError, type ProcessEntry, type SpawnedProcess, type SpawnOptions, type WatchChange, } from './client/attach.js';
+export type { DialledSocket, DialOptions } from './client/dial-stream.js';
+export type { LoopbackFetchOptions } from './client/loopback-fetch.js';
+export type { FacadeConnection, FacadeHook, FacadeInfo, FacadeSpec, FacadeSpecs, } from './facade/types.js';
+export type { Attestation, AttestedDir } from './fs/attest.js';
+export type { Denial, DenialHook } from './fs/dac.js';
+export type { ClipboardHook, ClipboardStamp } from './kernel/clipboard.js';
+export type { RouteTable } from './kernel/net/routes.js';
+export type { NetworkUplink, ResolveAnswer, ResolveFamily, UplinkTraits, } from './kernel/net/uplink.js';
+export type { SealedAbortReason, SealedCaller, SealedHook, SealedRequest, } from './kernel/sealed.js';
+export type { ConnectorStamp } from './kernel/socket.js';
+export { checkLocalProxy, type LocalProxyCheckOptions, type LocalProxyOptions, type LocalProxyProbe, type LocalProxyStatus, type LocalProxyTransportOptions, localProxyTransport, probeLocalProxy, } from './local-proxy-transport.js';
+export type { HostfsEvent, HostfsGrant, HostfsGrantHook, HostfsPortGrant, HostfsTransport, } from './mount/hostfs.js';
+export { serveHostfsPort } from './mount/hostfs.js';
+export type { MountEntry, MountSpec } from './mount/mount-fs.js';
+export type { ProcessMountPolicy, ProcessMountRequest } from './mount/syscall.js';
+export type { JsChild, JsExited, JsSpawnOptions, JsStdio } from './process/js/js-children.js';
+export type { JsFdStatus, JsFdType, JsFile, JsOpenOptions, JsProgramContext, JsSignal, JsSudoAnswer, } from './process/js/js-context.js';
+export type { JsStatFs } from './process/js/js-io.js';
+export type { JsAddress, JsConnection, JsConnectOptions, JsListener, JsListenOptions, JsNet, } from './process/js/js-net.js';
+export type { JsRunOptions, JsRunResult, JsRunStdio } from './process/js/js-run.js';
+export type { JsCred, JsSyncContext, JsSyncFile } from './process/js/js-sync.js';
+export type { JsTermios, JsTty, JsTtySize } from './process/js/js-tty.js';
+export type { JsWebSocket, JsWebSocketClose, JsWebSocketMessage, JsWebSocketOptions, } from './process/js/js-websocket.js';
+export type { ApproveHook, SudoAnswer, SudoRequest } from './sudo.js';
+export { type FetchTransportOptions, fetchTransport, type HeaderList, type NetworkExit, type NetworkRequest, type NetworkResponse, type NetworkTraits, type NetworkTransport, type NetworkWebSocket, type NetworkWebSocketRequest, } from './transport.js';
+export type { Account, AddUser, Group, RemoveUser } from './users.js';
+export interface NetworkOptions {
+    transport?: NetworkTransport;
+    uplink?: NetworkUplink;
+}
+export interface KernelOptions {
+    root?: FileSystemDirectoryHandle;
+    modules?: string;
+    commands?: {
+        append?: readonly string[];
+    };
+    env?: Record<string, string>;
+    metadata?: string | false;
+    media?: string | false;
+    ca?: string | false;
+    worker?: string | URL;
+    network?: NetworkOptions;
+    requestDirectory?: () => Promise<FileSystemDirectoryHandle>;
+    onMountPending?: (pending: MountPending) => void;
+    hostfs?: HostfsGrantHook;
+    processMounts?: ProcessMountPolicy;
+    cdp?: CdpHook;
+    facades?: FacadeSpecs;
+    hostname?: string;
+    users?: UsersMode;
+    onDenial?: DenialHook;
+    sealed?: SealedHook;
+    clipboard?: ClipboardHook;
+    approve?: ApproveHook;
+    protect?: Protection;
+}
+export interface MountPending {
+    target: string;
+    source: string;
+    insert(): Promise<void>;
+}
+export interface RunOptions {
+    cwd?: string;
+    user?: string | number;
+    tag?: string;
+    env?: Record<string, string>;
+    stdin?: string | Uint8Array;
+    onStdout?: (text: string) => void;
+    onStderr?: (text: string) => void;
+}
+export interface RunResult {
+    status: number;
+    signal?: string;
+    stdout: string;
+    stderr: string;
+}
+export interface ConnectOptions {
+    user?: string | number;
+    tag?: string;
+}
+export interface KernelGroups {
+    list(): Promise<Group[]>;
+    addMember(group: string, user: string): Promise<Group>;
+    removeMember(group: string, user: string): Promise<Group>;
+}
+export interface KernelUsers {
+    readonly mode: UsersMode;
+    add(user: AddUser): Promise<Account>;
+    remove(name: string, options?: RemoveUser): Promise<boolean>;
+    list(): Promise<Account[]>;
+}
+export interface KernelIntegrity {
+    revoke(path?: string): Promise<void>;
+}
+export interface Kernel {
+    run(argv: string[], options?: RunOptions): Promise<RunResult>;
+    openTerminal(argv: string[], options?: TerminalOptions): Promise<Terminal>;
+    connect(options?: ConnectOptions): Promise<MessagePort>;
+    readonly users: KernelUsers;
+    readonly groups: KernelGroups;
+    setRoutes(routes: RouteTable): Promise<void>;
+    chmod(path: string, mode: number): Promise<void>;
+    readonly integrity: KernelIntegrity;
+    updateTransportTraits(): Promise<boolean>;
+    dial(options: DialOptions): Promise<DialledSocket>;
+    loopbackFetch(input: RequestInfo | URL, options: LoopbackFetchOptions): Promise<Response>;
+    mount(spec: MountSpec): Promise<MountEntry>;
+    umount(target: string): Promise<void>;
+    mounts(): Promise<MountEntry[]>;
+    insert(target: string, handle: FileSystemDirectoryHandle): Promise<void>;
+    attest(path: string): Promise<Attestation>;
+    watch(paths: string[], onChange: (path: string) => void): Promise<() => void>;
+    terminate(): void;
+}
+export interface TerminalOptions {
+    cwd?: string;
+    user?: string | number;
+    tag?: string;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    onData?: (bytes: Uint8Array) => void;
+}
+export type TerminalSignal = 'SIGINT' | 'SIGTSTP' | 'SIGQUIT' | 'SIGHUP' | 'SIGTERM' | 'SIGKILL' | 'SIGCONT';
+export interface Ended {
+    status: number;
+    signal?: string;
+}
+export interface Terminal {
+    readonly pid: number;
+    readonly exited: Promise<number>;
+    readonly ended: Promise<Ended>;
+    onData: ((bytes: Uint8Array) => void) | null;
+    write(data: string | Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    signal(name: TerminalSignal): void;
+    close(): void;
+}
+export declare function createKernel(options?: KernelOptions): Promise<Kernel>;

package/dist/types/integrity-relay.d.ts

@@ -0,0 +1,18 @@
+import type { IntegrityLookup } from './fs/integrity.js';
+export interface IntegrityPort {
+    postMessage(message: unknown): void;
+}
+export interface IntegrityAsk {
+    id: number;
+    path: string;
+}
+export interface IntegrityReply {
+    id: number;
+    hash?: string;
+    error?: string;
+}
+export declare function integrityAsker(port: IntegrityPort): {
+    lookup: IntegrityLookup;
+    answer(reply: IntegrityReply): void;
+};
+export declare function integrityAnswerer(port: IntegrityPort, lookup: IntegrityLookup | undefined): (data: unknown) => boolean;

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

@@ -0,0 +1,90 @@
+import type { Cred } from './cred.js';
+import { type DeviceMeta, FdTable, type KernelErrno } from './fd-table.js';
+import type { ForkState } from './protocol.js';
+export type ChildStdio = {
+    fd: number;
+} | {
+    input: Uint8Array;
+} | {
+    capture: true;
+    max?: number;
+    overflow?: () => void;
+    control?: CaptureControl;
+} | {
+    sameAs: number;
+} | {
+    none: true;
+} | {
+    dir: string;
+} | DeviceMeta;
+export interface CaptureControl {
+    shut: boolean;
+    opened?: boolean;
+    ended(): void;
+}
+export type InheritedSlot = {
+    fd: number;
+    kernel: number;
+    flags?: number;
+} | ({
+    fd: number;
+} & DeviceMeta);
+export interface ChildSpawnRequest {
+    file: string;
+    argv: string[];
+    argv0?: string;
+    env: Record<string, string>;
+    cwd: string;
+    pgid?: number;
+    session?: true;
+    exec?: boolean;
+}
+export interface ChildHandle {
+    pid: number;
+    exited: Promise<number>;
+    termsig?: () => number | undefined;
+    onState?: (listener: ChildStateListener) => void;
+}
+export type ChildStateListener = (state: 'stopped' | 'continued', sig: number) => void;
+export interface WaitFlags {
+    untraced?: boolean;
+    continued?: boolean;
+    inGroup?: (childPid: number) => boolean;
+}
+export declare class SpawnError extends Error {
+    readonly code: KernelErrno;
+    constructor(code: KernelErrno);
+}
+export interface SpawnGrant {
+    cred: Cred;
+    caller: Cred;
+}
+export type ChildSpawner = (req: ChildSpawnRequest, fds: FdTable, grant?: SpawnGrant) => Promise<ChildHandle>;
+export type ChildForker = (state: ForkState, fds: FdTable) => Promise<ChildHandle>;
+export declare function stoppedStatus(sig: number): number;
+export declare const CONTINUED_STATUS = 65535;
+export declare function waitStatus(code: number, termsig?: number): number;
+export declare class ChildTable {
+    private readonly children;
+    private readonly leftovers;
+    onChildState?: () => void;
+    onReap?: (pid: number) => void;
+    private stateChanged;
+    private readonly watchers;
+    private readonly parentFds;
+    private readonly spawner;
+    private readonly forker?;
+    constructor(parentFds: FdTable, spawner: ChildSpawner | undefined, forker?: ChildForker);
+    fork(state: ForkState): Promise<number>;
+    spawn(req: ChildSpawnRequest, stdio: readonly ChildStdio[], inherit?: readonly InheritedSlot[], grant?: SpawnGrant): Promise<number>;
+    private track;
+    watch(pid: number, listener: ChildStateListener): void;
+    private openSlot;
+    wait(pid: number, nohang: boolean, signal?: AbortSignal, flags?: WaitFlags): Promise<[number, number]>;
+    private candidates;
+    private nextChange;
+    private stateReport;
+    private reap;
+    pids(): number[];
+    captured(pid: number, slot: number): Uint8Array;
+}

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

@@ -0,0 +1,49 @@
+import type { UsersMode } from '../fs/types.js';
+import { KernelError, type OpenAccess, OpenFile, type PollState } from './fd-table.js';
+export declare const CLIPBOARD_PATH = "/dev/clipboard";
+export declare const CLIPBOARD_MINOR = 251;
+export declare const CLIPBOARD_MAX_BYTES: number;
+export declare const CLIPBOARD_TIMEOUT_MS = 10000;
+export interface ClipboardStamp {
+    pid: number;
+    uid: number;
+    gid: number;
+    users: UsersMode;
+    tag?: string;
+}
+export interface ClipboardHook {
+    read(stamp: ClipboardStamp): Promise<string>;
+    write(text: string, stamp: ClipboardStamp): Promise<void>;
+}
+export declare function clipboardFailure(err: unknown): KernelError;
+declare class ClipboardChannel {
+    stamp: ClipboardStamp;
+    readonly access: OpenAccess;
+    private readonly broker;
+    private snapshot;
+    private taken;
+    private offset;
+    private chunks;
+    private size;
+    private wrote;
+    private failed;
+    private aborted;
+    constructor(broker: ClipboardBroker, access: OpenAccess, stamp: ClipboardStamp);
+    get unread(): boolean;
+    get settled(): boolean;
+    read(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    write(bytes: Uint8Array): number;
+    poll(): PollState;
+    abort(): void;
+    close(): Promise<void>;
+}
+export declare class ClipboardBroker {
+    readonly hook: ClipboardHook | undefined;
+    readonly users: UsersMode;
+    readonly timeoutMs: number;
+    readonly tagOf: (pid: number) => string | undefined;
+    constructor(hook: ClipboardHook | undefined, users: UsersMode, timeoutMs?: number, tagOf?: (pid: number) => string | undefined);
+    ask<T>(work: (hook: ClipboardHook) => Promise<T>): Promise<T>;
+    open(access: OpenAccess, stamp: ClipboardStamp): OpenFile;
+}
+export type { ClipboardChannel };

package/dist/types/kernel/cpu-clock.d.ts

@@ -0,0 +1,56 @@
+export declare const SYS_CAP_US = 20000;
+export declare function epochMicros(): number;
+export declare const rawWait: (typed: Int32Array, index: number, value: number, timeout?: number) => 'ok' | 'not-equal' | 'timed-out';
+export declare function useLocalClock(sab: SharedArrayBuffer | undefined): void;
+export declare function localWait<T>(wait: () => T, blocks?: boolean): T;
+export declare function localCpuNanos(): bigint | undefined;
+export declare function localIdle(sab: SharedArrayBuffer, now: number): {
+    idle: number;
+    waiting: boolean;
+};
+export interface CpuTimes {
+    utime: number;
+    stime: number;
+}
+export declare class CpuClock {
+    private readonly start;
+    private sys;
+    private idle;
+    private since;
+    private kind;
+    private stopped;
+    private last;
+    private readonly sab;
+    private readonly now;
+    constructor(sab: SharedArrayBuffer, now?: () => number);
+    enter(): void;
+    block(): void;
+    leave(): void;
+    stop(stopped: boolean): void;
+    private frozen;
+    freeze(): void;
+    running(): boolean;
+    times(): CpuTimes;
+    private add;
+}
+export declare class ProcessClocks {
+    private readonly main;
+    private readonly threads;
+    private readonly ended;
+    private readonly enabled;
+    constructor(sab: SharedArrayBuffer, enabled?: boolean, states?: {
+        onState(listener: (state: string) => void): void;
+    });
+    thread(tid: number, sab: SharedArrayBuffer): CpuClock;
+    threadEnded(tid: number): void;
+    stop(stopped: boolean): void;
+    freeze(): void;
+    times(): CpuTimes | undefined;
+    running(): number;
+    states(): Array<{
+        tid: number;
+        state: 'R' | 'S';
+    }>;
+    timed<R, T>(clock: CpuClock | undefined, dispatch: (req: R, block: () => void) => Promise<T>): (req: R) => Promise<T>;
+    private all;
+}

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

@@ -0,0 +1,17 @@
+export interface Cred {
+    ruid: number;
+    euid: number;
+    suid: number;
+    rgid: number;
+    egid: number;
+    sgid: number;
+    groups: number[];
+}
+export type CredChange = Partial<Cred>;
+export declare const ROOT: Readonly<Cred>;
+export declare const MAX_GROUPS = 65536;
+export declare function userCred(uid: number, gid: number, groups?: number[]): Cred;
+export declare function copyCred(cred: Readonly<Cred>): Cred;
+export declare function changeCred(cur: Readonly<Cred>, change: CredChange): Cred;
+export declare function maySignal(sender: Readonly<Cred>, target: Readonly<Cred>): boolean;
+export declare function maySee(viewer: Readonly<Cred>, target: Readonly<Cred>): boolean;

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

@@ -0,0 +1,56 @@
+import { type KernelFile, type PollState } from './fd-table.js';
+import { type LoopbackNet, type SockAddr } from './socket.js';
+export type InetAddr = Extract<SockAddr, {
+    family: 'inet';
+}>;
+export interface Datagram {
+    bytes: Uint8Array;
+    from: InetAddr;
+}
+export interface Received {
+    bytes: Uint8Array;
+    from: InetAddr;
+    truncated: boolean;
+}
+export declare const DGRAM_QUEUE_BYTES: number;
+export declare const DGRAM_QUEUE_COUNT = 512;
+export declare const DGRAM_SEND_ROOM: number;
+export declare const MAX_DATAGRAM_V4 = 65507;
+export declare const MAX_DATAGRAM_V6 = 65527;
+export declare class KernelDgram implements KernelFile {
+    local: InetAddr | undefined;
+    peer: InetAddr | undefined;
+    private readonly net;
+    private readonly queue;
+    private queued;
+    private pending;
+    private closed;
+    private sending;
+    private readonly changes;
+    private readonly options;
+    private readonly uplinks;
+    private readonly stop;
+    constructor(net: LoopbackNet);
+    bind(addr: SockAddr): void;
+    private bound;
+    connectTo(addr: SockAddr): void;
+    private drain;
+    private route;
+    private takeError;
+    send(bytes: Uint8Array, to?: SockAddr): Promise<number>;
+    private sendUp;
+    private uplinkSocket;
+    private pump;
+    private unreachable;
+    deliver(datagram: Datagram): boolean;
+    receive(max: number, peek: boolean, signal?: AbortSignal): Promise<Received>;
+    read(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    peek(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    write(bytes: Uint8Array): Promise<number>;
+    poll(): PollState;
+    changed(signal?: AbortSignal): Promise<void>;
+    shutdown(how: number): void;
+    getOption(level: number, name: number): number;
+    setOption(level: number, name: number, value: number): void;
+    close(): void;
+}