@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.1

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

@@ -0,0 +1,131 @@
+import type { Datagram, InetAddr, KernelDgram } from './dgram.js';
+import { type KernelFile, type PollState } from './fd-table.js';
+import { type Destination, Routes } from './net/routes.js';
+import type { NetworkUplink } from './net/uplink.js';
+import { KernelPipe } from './pipe.js';
+import type { SealedCaller } from './sealed.js';
+export type SockAddr = {
+    family: 'inet';
+    host: string;
+    port: number;
+} | {
+    family: 'unix';
+    path: string;
+};
+export type SocketDomain = SockAddr['family'];
+export declare const SHUT_RD = 0;
+export declare const SHUT_WR = 1;
+export declare const SHUT_RDWR = 2;
+export declare const DIAL_TIMEOUT_MS = 30000;
+export interface UplinkRoute {
+    uplink: NetworkUplink;
+    routes: Routes;
+    timeoutMs?: number;
+}
+export declare function isLoopback(host: string): boolean;
+export declare class Changes {
+    private waiters;
+    wait(signal?: AbortSignal): Promise<void>;
+    wake(): void;
+}
+interface Link {
+    rx: KernelPipe;
+    tx: KernelPipe;
+}
+export interface PeerCred {
+    pid: number;
+    uid: number;
+    gid: number;
+}
+export type ConnectorStamp = SealedCaller;
+export interface SocketName {
+    key: string;
+    typed: boolean;
+}
+export declare class KernelSocket implements KernelFile {
+    private readonly net;
+    readonly domain: SocketDomain;
+    private state;
+    private dialing;
+    private failed;
+    private reset;
+    local: SockAddr | undefined;
+    peer: SockAddr | undefined;
+    peerCred: PeerCred | undefined;
+    peerStamp: ConnectorStamp | undefined;
+    private listenerCred;
+    private link;
+    private readShut;
+    private writeShut;
+    private readonly queue;
+    private backlog;
+    private boundAt;
+    named: SocketName | undefined;
+    private readonly changes;
+    private readonly room;
+    private readonly options;
+    constructor(net: LoopbackNet, domain: SocketDomain);
+    attach(link: Link): void;
+    get listening(): boolean;
+    get unconnected(): boolean;
+    private connection;
+    read(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    peek(max: number, signal?: AbortSignal): Promise<Uint8Array>;
+    write(bytes: Uint8Array, signal?: AbortSignal): Promise<number>;
+    poll(): PollState;
+    changed(signal?: AbortSignal): Promise<void>;
+    bindable(addr: SockAddr): void;
+    bind(addr: SockAddr, kernel?: boolean, name?: SocketName): void;
+    listen(backlog: number, cred?: PeerCred): void;
+    accept(signal?: AbortSignal, nonblock?: boolean): Promise<KernelSocket>;
+    offer(server: KernelSocket): boolean;
+    get full(): boolean;
+    waitRoom(signal: AbortSignal): Promise<void>;
+    connect(addr: SockAddr, viaUplink?: boolean, cred?: PeerCred, stamp?: ConnectorStamp, waits?: boolean, name?: SocketName): Promise<void> | undefined;
+    private join;
+    private queued;
+    private dial;
+    private unlink;
+    shutdown(how: number): void;
+    getOption(level: number, name: number): number;
+    setOption(level: number, name: number, value: number): void;
+    close(): void;
+    static pair(net: LoopbackNet, domain: SocketDomain, cred?: PeerCred): [KernelSocket, KernelSocket];
+}
+export declare function canonicalHost(host: string): string;
+export declare class LoopbackNet {
+    private readonly bound;
+    private readonly dgrams;
+    private readonly activators;
+    private readonly internal;
+    private readonly reserved;
+    private readonly facades;
+    private nextEphemeral;
+    private route;
+    useUplink(route: UplinkRoute): void;
+    uplinkFor(host: string): UplinkRoute | undefined;
+    destination(host: string): Destination;
+    bindDgram(socket: KernelDgram, addr: SockAddr, kernel?: boolean): InetAddr;
+    releaseDgram(addr: InetAddr, socket: KernelDgram): void;
+    deliverDgram(port: number, datagram: Datagram): boolean;
+    private bindable;
+    kernelOnly(port: number, reserve?: boolean): boolean;
+    reserve(port: number): void;
+    facade(port: number, name: string): void;
+    facadeAt(addr: SockAddr): string | undefined;
+    activate(addr: SockAddr, start: () => void): void;
+    socket(domain: SocketDomain): KernelSocket;
+    listen(addr: SockAddr, backlog?: number): KernelSocket;
+    backlogWaitMs: number;
+    connect(addr: SockAddr): KernelSocket;
+    bind(socket: KernelSocket, addr: SockAddr, kernel?: boolean, name?: SocketName): SockAddr;
+    release(addr: SockAddr, socket: KernelSocket, name?: SocketName): void;
+    target(addr: SockAddr, name?: SocketName): KernelSocket;
+    private ephemeral;
+}
+export declare function loopbackNet(owner: string): LoopbackNet;
+export declare function ownerKey(owner: {
+    kind: string;
+    scoopJid?: string;
+} | undefined): string;
+export {};

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

@@ -0,0 +1,4 @@
+export declare const TIMER_MAX_MS = 2147483647;
+export declare function timerAt(deadline: number, fire: () => void): () => void;
+export declare function timerAfter(ms: number, fire: () => void): () => void;
+export declare function repeating(first: number, every: number, fire: () => void): () => void;

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

@@ -0,0 +1,53 @@
+import type { Perm } from '../fs/types.js';
+import { OpenFile } from './fd-table.js';
+export interface Termios {
+    c_iflag: number;
+    c_oflag: number;
+    c_cflag: number;
+    c_lflag: number;
+    c_cc: number[];
+}
+export interface TtyScreen {
+    write(bytes: Uint8Array): void;
+}
+export declare function defaultTermios(): Termios;
+export declare class KernelTty {
+    private termios;
+    private cols;
+    private rows;
+    private readable;
+    private line;
+    private waiters;
+    private hungUp;
+    name?: string;
+    owner?: Perm;
+    onRead?: () => void;
+    private readers;
+    private readonly screen;
+    private readonly signal;
+    constructor(screen: TtyScreen, signal: (sig: number) => void);
+    receive(bytes: Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    hangup(): void;
+    signalHangup(): void;
+    setSize(cols: number, rows: number): void;
+    tcgets(): Termios;
+    tcsets(termios: Termios, flush?: boolean): void;
+    winsize(): [number, number];
+    file(): OpenFile;
+    private get canonical();
+    private cc;
+    private key;
+    private signalKey;
+    private edit;
+    private lastWordLength;
+    private lastCharLength;
+    private rubOut;
+    private echo;
+    private output;
+    get reading(): boolean;
+    private read;
+    private take;
+    private changed;
+    private wake;
+}

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

@@ -0,0 +1,149 @@
+import { type AsyncRangedIo } from '../fs/ranged.js';
+import { type KernelFs, type NewOwner, type OwnerChange } from '../fs/types.js';
+import type { KeptFile, UnlinkHolder } from '../fs/unlinked.js';
+import { OpenFile } from './fd-table.js';
+export interface VfsFileFs extends Partial<AsyncRangedIo> {
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: Uint8Array, owner?: NewOwner): Promise<void>;
+    mayChange?(path: string, follow: boolean, whole?: boolean): Promise<void>;
+    stat?(path: string): Promise<{
+        readonly?: boolean;
+        maxFile?: number;
+        size?: number;
+        ranged?: boolean;
+        version?: string;
+        ino?: number;
+        dev?: number;
+        nlink?: number;
+    }>;
+    readlink?(path: string): Promise<string>;
+    lstat?(path: string): Promise<unknown>;
+    realpath?(path: string, follow: boolean): Promise<string>;
+    chown?(path: string, change: OwnerChange): Promise<void>;
+    chmod?(path: string, mode: number): Promise<void>;
+    links?(path: string): boolean;
+    exclusive?<T>(path: string, run: () => Promise<T>): Promise<T>;
+}
+export interface VfsFileOptions {
+    path: string;
+    flags: number;
+    position: number;
+    contents?: Uint8Array;
+    orphan?: boolean;
+    dirty?: boolean;
+    pin?: VersionPin;
+    truncate?: boolean;
+    create?: boolean;
+    id?: string;
+}
+export interface VersionPin {
+    version: string;
+    size: number;
+}
+export declare const WRITEBACK_MS = 250;
+export declare class VfsNode {
+    private data;
+    private ranged;
+    private readonly pin;
+    private length;
+    private dirty;
+    private queue;
+    private writeBack;
+    private writeBackCost;
+    opens: number;
+    writers: number;
+    private missing;
+    private revoked;
+    private readonly fs;
+    path: string;
+    orphaned: boolean;
+    id: string | undefined;
+    onDirty: (() => void) | undefined;
+    onDirtyState: ((on: boolean) => void) | undefined;
+    private counted;
+    recount(): void;
+    constructor(fs: VfsFileFs, path: string, contents?: Uint8Array, orphaned?: boolean, dirty?: boolean, pin?: VersionPin);
+    serial<T>(op: () => Promise<T>): Promise<T>;
+    revoke(): void;
+    private prepare;
+    keep(): Promise<void>;
+    load(): Promise<Uint8Array>;
+    holds(): boolean;
+    replace(contents: Uint8Array): void;
+    materialize(): Promise<void>;
+    size(): Promise<number>;
+    pread(max: number, at: number): Promise<Uint8Array>;
+    private cap;
+    limit(): Promise<number | undefined>;
+    private seen;
+    private note;
+    known(): number | undefined;
+    private fits;
+    renamedTo(path: string): void;
+    pwrite(bytes: Uint8Array, at: number): Promise<number>;
+    truncate(size: number): Promise<void>;
+    private markDirty;
+    private ensure;
+    flush(): Promise<void>;
+}
+export declare class VfsNodes implements UnlinkHolder {
+    private readonly byPath;
+    private readonly kept;
+    private readonly byId;
+    keepsOnDisk: boolean;
+    changed: ((path: string) => void) | undefined;
+    dirtied: ((delta: number) => void) | undefined;
+    private readonly fs;
+    readonly entries: Map<string, Promise<unknown>>;
+    private readonly onClosed;
+    constructor(fs: VfsFileFs, onClosed?: (path: string) => void, entries?: Map<string, Promise<unknown>>);
+    onEntry<T>(path: string, op: () => Promise<T>): Promise<T>;
+    entryKey(path: string): Promise<string>;
+    targetKey(path: string): Promise<string>;
+    private real;
+    createExclusive(path: string, owner?: NewOwner): Promise<void>;
+    private identity;
+    identify(path: string): Promise<string | undefined>;
+    flushLinked(path: string): Promise<void>;
+    linked(from: string, to: string): Promise<void>;
+    private know;
+    private namesOf;
+    private forget;
+    private orphan;
+    private dropName;
+    holdsAny(): boolean;
+    private epoch;
+    private readonly plain;
+    reshaped(): void;
+    plainAt(path: string): boolean;
+    get shape(): number;
+    notePlain(path: string, shape: number): void;
+    holdsName(name: string): boolean;
+    holdsLinked(): boolean;
+    holdingId(id: string): VfsNode | undefined;
+    holding(path: string): VfsNode | undefined;
+    private named;
+    private create;
+    open(path: string, pin?: VersionPin, writable?: boolean, id?: string): VfsNode;
+    adopt(path: string, contents: Uint8Array, dirty: boolean, writable?: boolean, id?: string): VfsNode;
+    holds(prefix: string): boolean;
+    writes(prefix: string): boolean;
+    closed(node: VfsNode, writable?: boolean): void;
+    held(): Iterable<string>;
+    owns(): boolean;
+    isKept(): boolean;
+    keep(path: string, file: KeptFile): void;
+    unkeep(path: string, file: KeptFile): void;
+    flush(path: string): Promise<void>;
+    unlinking(path: string): Promise<void>;
+    revoke(prefix: string): void;
+    unlinked(path: string): void;
+    renamed(from: string, to: string): void;
+}
+export declare function present(fs: VfsFileFs, path: string, follow?: boolean): Promise<boolean>;
+export declare function refuseReadonly(fs: VfsFileFs, path: string, flags: number, opts?: {
+    create?: boolean;
+    truncate?: boolean;
+}): Promise<void>;
+export declare function keepingOpen(fs: KernelFs, nodes: VfsNodes, changed?: (path: string) => void): KernelFs;
+export declare function vfsFile(fs: VfsFileFs, opts: VfsFileOptions, nodes?: VfsNodes): OpenFile;

package/dist/types/launcher.d.ts

@@ -0,0 +1,359 @@
+import { CdpHosts } from './cdp/hosts.js';
+import type { CdpHook } from './cdp/types.js';
+import { type Abi, type Command } from './commands.js';
+import { FacadeHosts } from './facade/hosts.js';
+import type { FacadeSpecs } from './facade/types.js';
+import { type Attestation } from './fs/attest.js';
+import { Dac, type DenialHook } from './fs/dac.js';
+import { type Protection } from './fs/protect.js';
+import type { KernelFs, UsersMode } from './fs/types.js';
+import { type UnlinkOwner } from './fs/unlinked.js';
+import { FsWatchers } from './fs/watch.js';
+import { type ClipboardHook } from './kernel/clipboard.js';
+import type { CpuTimes } from './kernel/cpu-clock.js';
+import { type Cred } from './kernel/cred.js';
+import { type WasmWorkerLike } from './kernel/host.js';
+import type { CaStore } from './kernel/net/realm-ca.js';
+import { Resolver } from './kernel/net/resolver.js';
+import { Routes, type RouteTable } from './kernel/net/routes.js';
+import type { RealmTransport } from './kernel/net/transport.js';
+import type { NetworkUplink } from './kernel/net/uplink.js';
+import type { ProcessInfo } from './kernel/proc-info.js';
+import { type SealedCaller, type SealedHook } from './kernel/sealed.js';
+import { LoopbackNet } from './kernel/socket.js';
+import { type MediumHandle } from './mount/fsa.js';
+import { type FstabResult } from './mount/fstab.js';
+import { type FetchLike, type HostfsGrantHook, type HostfsTiming } from './mount/hostfs.js';
+import { type MediaStore } from './mount/media.js';
+import { type MountEntry, type MountSpec, MountTable } from './mount/mount-fs.js';
+import { type ProcessMountPolicy } from './mount/syscall.js';
+import { type ApproveHook } from './sudo.js';
+import { type Account, UserDb } from './users.js';
+export interface LauncherOptions {
+    unlinkOwner?: UnlinkOwner;
+    fs: KernelFs;
+    createWorker: () => WasmWorkerLike;
+    modules?: string;
+    commands?: {
+        append?: readonly string[];
+    };
+    env?: Record<string, string>;
+    transport?: RealmTransport;
+    caStore?: CaStore;
+    createDriverWorker?: () => WasmWorkerLike;
+    media?: MediaStore;
+    onMountPending?: (pending: PendingMedium) => void;
+    hostfs?: HostfsGrantHook;
+    hostfsFetch?: FetchLike;
+    hostfsTiming?: HostfsTiming;
+    processMounts?: ProcessMountPolicy;
+    fstabRetries?: readonly number[];
+    cdp?: CdpHook;
+    facades?: FacadeSpecs;
+    uplink?: NetworkUplink;
+    hostname?: string;
+    users?: UsersMode;
+    onDenial?: DenialHook;
+    sealed?: SealedHook;
+    clipboard?: ClipboardHook;
+    approve?: ApproveHook;
+    sudoTimeoutMs?: number;
+    protect?: Protection;
+}
+export interface PendingMedium {
+    target: string;
+    source: string;
+    handle?: MediumHandle;
+}
+export interface RunOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    stdin?: Uint8Array;
+    onStdout?: (bytes: Uint8Array) => void;
+    onStderr?: (bytes: Uint8Array) => void;
+    onStarted?: (pid: number) => void;
+    collect?: boolean;
+    pgid?: number;
+    user?: string | number | Account;
+    tag?: string;
+}
+export interface TerminalOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    user?: string | number | Account;
+    tag?: string;
+    onData: (bytes: Uint8Array) => void;
+}
+export interface TerminalSession {
+    pid: number;
+    exited: Promise<number>;
+    termsig(): number | undefined;
+    write(bytes: Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    signal(sig: number): void;
+    close(): void;
+}
+export interface RunResult {
+    status: number;
+    signal?: number;
+    stdout: Uint8Array;
+    stderr: Uint8Array;
+}
+interface Target {
+    abi: Abi;
+    glue: string;
+    wasm: string;
+    argv0: string;
+    fixed?: true;
+    prefix?: string[];
+    env?: Record<string, string>;
+    unset?: string[];
+    imports?: string;
+    preopenRoot?: boolean;
+    asked?: string;
+}
+export declare function tagOption(tag: unknown): void;
+export declare function expandDefaults(defaults: Readonly<Record<string, string>> | undefined, env: Readonly<Record<string, string>>): Record<string, string>;
+export declare class Launcher {
+    readonly fs: KernelFs;
+    readonly processFs: KernelFs;
+    private readonly noLinksFs;
+    private readonly mounted;
+    private protection;
+    private readonly prefixes;
+    private readonly writerTags;
+    private readonly unguardedRoot;
+    private writers;
+    private readonly unlinkOwnerOption;
+    private readonly base;
+    private readonly createWorker;
+    private readonly modulesDir;
+    private readonly appended;
+    private readonly reportedRoots;
+    private readonly env;
+    private readonly catalogs;
+    private readonly ownCatalogs;
+    private readonly binfmts;
+    private scopes;
+    private unwatchScopes;
+    private readonly warned;
+    private readonly compiled;
+    private readonly texts;
+    private revocations;
+    private integrity;
+    private scannedFs;
+    private get scanned();
+    private readonly processes;
+    private readonly zombies;
+    private readonly orphans;
+    private readonly described;
+    private readonly creds;
+    private readonly tags;
+    private readonly links;
+    private readonly freshModules;
+    private readonly granted;
+    readonly users: UserDb;
+    private readonly sudoer;
+    private readonly jobs;
+    private readonly locks;
+    private readonly sems;
+    private readonly settling;
+    private readonly ptys;
+    readonly net: LoopbackNet;
+    readonly cdp: CdpHosts;
+    readonly facades: FacadeHosts;
+    private readonly ca;
+    readonly transport: RealmTransport;
+    readonly uplink: NetworkUplink | undefined;
+    readonly routes: Routes;
+    readonly resolver: Resolver;
+    readonly hostname: string;
+    readonly watchers: FsWatchers;
+    private readonly changes;
+    private readonly pnpmHome;
+    private readonly pnpmChain;
+    private pnpmMade;
+    private pnpmEpoch;
+    readonly mounts: MountTable;
+    private readonly createDriverWorker;
+    private readonly media;
+    private readonly onMountPending;
+    private readonly removable;
+    private readonly hostfs;
+    private readonly fstabRetries;
+    private readonly inserted;
+    private readonly openFiles;
+    private readonly deciding;
+    readonly identities: {
+        asked: number;
+        timedOut: number;
+    };
+    private readonly nodes;
+    private readonly unlinked;
+    private readonly held;
+    private readonly processMounts;
+    private readonly booting;
+    fstab: Promise<FstabResult[]>;
+    readonly usersMode: UsersMode;
+    readonly dac: Dac | undefined;
+    private readonly sealed;
+    private readonly scrubs;
+    private readonly clipboard;
+    private readonly rootFs;
+    private fileWatches;
+    private nextPid;
+    readonly boot: number;
+    private terminals;
+    constructor(options: LauncherOptions);
+    get owners(): boolean;
+    setRoutes(table: RouteTable): void;
+    private readonly traitsListeners;
+    private announcedTraits;
+    onTraits(listener: () => void): () => void;
+    updateTransportTraits(): boolean;
+    commands(scope?: string): Promise<Map<string, Command>>;
+    private ownCommands;
+    private interpreters;
+    private tiers;
+    private roots;
+    private rootOnlyPath;
+    private trustedAppended;
+    private resetCatalogs;
+    private userScopes;
+    private userCommandDir;
+    private scopeOf;
+    private commandAt;
+    resolve(file: string, argv0: string, cwd: string, scope?: string): Promise<Target | undefined>;
+    private glueOwner;
+    private wasmOwner;
+    private head;
+    private scriptCommand;
+    private interpreted;
+    private plan;
+    private mayExec;
+    private checkedPlan;
+    private execGuard;
+    private execFile;
+    private ticketFile;
+    private takeTicket;
+    private redeemed;
+    private redeem;
+    private interpreterChain;
+    private commandFile;
+    private trustedFiles;
+    private grantedCwd;
+    private binfmtManifests;
+    private backing;
+    private backingOf;
+    private unrunnable;
+    private directory;
+    verifiedFs(fs: KernelFs): KernelFs;
+    private cacheKey;
+    private verified;
+    private keyed;
+    private cached;
+    private module;
+    private checkedSources;
+    private text;
+    private names;
+    private program;
+    private launch;
+    groupSession(pgid: number): number | undefined;
+    private loopbackFor;
+    private sourceCheck;
+    private treeScrubs;
+    private marks;
+    private start;
+    private shownIds;
+    private forget;
+    private reaped;
+    private load;
+    private sampler;
+    private readonly reapedTimes;
+    private readonly idleAt;
+    cpuTotal(now?: number): CpuTimes & {
+        idle: number;
+    };
+    loadAverage(): readonly [number, number, number];
+    private sampledAt;
+    sampleLoad(now?: number): void;
+    private idleSince;
+    private sampling;
+    private readonly spent;
+    private readonly imageTimes;
+    private readonly childTimes;
+    private readonly stopped;
+    private stateOf;
+    private childrenOf;
+    private timesAt;
+    private timesOf;
+    list(viewer?: Readonly<Cred>): ProcessInfo[];
+    private threadsOf;
+    private sudo;
+    private spawner;
+    private childGroup;
+    private undecided;
+    connectorStamp(pid: number): Promise<SealedCaller>;
+    private identityOf;
+    private running;
+    private decide;
+    private forker;
+    private keySignal;
+    private resolvePrefixes;
+    private guardMount;
+    private umaskOf;
+    private imageOf;
+    credOf(pid: number): Cred;
+    tagOf(pid: number): string | undefined;
+    private released;
+    private signalMasksOf;
+    private controlsJobs;
+    private blockedBy;
+    private ignoredBy;
+    kill(pid: number, sig: number, sender?: Readonly<Cred>, from?: number): boolean;
+    private killAll;
+    private driver;
+    private fsaDriver;
+    revokeIntegrity(path?: string): Promise<void>;
+    attest(path: string): Promise<Attestation>;
+    watchFiles(paths: readonly string[], notify: (path: string) => void): Promise<() => void>;
+    mount(spec: MountSpec): Promise<MountEntry>;
+    private mountShm;
+    private ownTmp;
+    private inUse;
+    private stampLayout;
+    private realLayoutPath;
+    private pnpmReady;
+    private pnpmStale;
+    private mountedBy;
+    private mountRoot;
+    insert(target: string, handle: MediumHandle, source?: string): Promise<void>;
+    umount(target: string, detach?: boolean): void;
+    unmountAll(): void;
+    private permit;
+    private processMount;
+    mountAs(cred: Cred, spec: MountSpec): Promise<MountEntry>;
+    umountAs(cred: Cred, target: string): Promise<void>;
+    private mountsOwn;
+    private processUmount;
+    prepare(): Promise<void>;
+    private mountFstab;
+    private environment;
+    private account;
+    private terminalAccount;
+    private identity;
+    fsFor(tag: string | undefined): KernelFs;
+    isWriter(tag: string | undefined): boolean;
+    private stackFor;
+    private writerStack;
+    private noLinksOf;
+    private rooted;
+    private commandFs;
+    private processChain;
+    private starting;
+    openTerminal(argv: string[], options: TerminalOptions): Promise<TerminalSession>;
+    run(argv: string[], options?: RunOptions): Promise<RunResult>;
+}
+export type { ProcessInfo, ProcessListing } from './kernel/proc-info.js';