@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.0

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

@@ -0,0 +1,163 @@
+import { type RouteTable } from './routes.js';
+export interface UplinkTraits {
+    tcp: true;
+    udp: boolean;
+    ipv6: boolean;
+}
+export type ResolveFamily = 0 | 4 | 6;
+export interface ResolveAnswer {
+    addresses: string[];
+    ttl?: number;
+}
+export interface UplinkConn {
+    readonly localAddr: string;
+    readonly remoteAddr: string;
+    read(): Promise<Uint8Array | null>;
+    write(bytes: Uint8Array): Promise<number>;
+    closeWrite(): void;
+    close(): void;
+}
+export interface UplinkDial {
+    network: 'tcp';
+    host: string;
+    port: number;
+    signal: AbortSignal;
+}
+export interface UplinkDatagram {
+    bytes: Uint8Array;
+    host: string;
+    port: number;
+}
+export interface UplinkUnreachable {
+    error: string;
+    host: string;
+    port: number;
+}
+export type UplinkMessage = UplinkDatagram | UplinkUnreachable;
+export interface UplinkUdpOpen {
+    family: 4 | 6;
+    signal: AbortSignal;
+}
+export interface UplinkUdp {
+    readonly localAddr: string;
+    send(bytes: Uint8Array, host: string, port: number): Promise<void>;
+    readonly messages: AsyncIterable<UplinkMessage>;
+    close(): void;
+}
+export interface NetworkUplink {
+    readonly traits: UplinkTraits;
+    readonly routes?: RouteTable;
+    resolve(name: string, family: ResolveFamily, signal?: AbortSignal): Promise<string[] | ResolveAnswer>;
+    dial(req: UplinkDial): Promise<UplinkConn>;
+    udp?(req: UplinkUdpOpen): Promise<UplinkUdp>;
+}
+export declare function carriesUdp(uplink: NetworkUplink): boolean;
+export type UplinkCall = {
+    uplink: 'resolve';
+    uid: number;
+    name: string;
+    family: ResolveFamily;
+} | {
+    uplink: 'dial';
+    uid: number;
+    host: string;
+    port: number;
+} | {
+    uplink: 'cancel';
+    uid: number;
+} | {
+    uplink: 'read';
+    uid: number;
+    cid: number;
+} | {
+    uplink: 'write';
+    uid: number;
+    cid: number;
+    bytes: Uint8Array;
+} | {
+    uplink: 'close-write';
+    cid: number;
+} | {
+    uplink: 'close';
+    cid: number;
+} | {
+    uplink: 'udp-open';
+    uid: number;
+    family: 4 | 6;
+} | {
+    uplink: 'udp-send';
+    uid: number;
+    cid: number;
+    bytes: Uint8Array;
+    host: string;
+    port: number;
+} | {
+    uplink: 'udp-recv';
+    uid: number;
+    cid: number;
+} | {
+    uplink: 'udp-close';
+    cid: number;
+};
+export type UplinkReply = {
+    uplink: 'resolved';
+    uid: number;
+    addresses: string[];
+    ttl?: number;
+} | {
+    uplink: 'dialled';
+    uid: number;
+    cid: number;
+    localAddr: string;
+    remoteAddr: string;
+} | {
+    uplink: 'data';
+    uid: number;
+    bytes: Uint8Array | null;
+} | {
+    uplink: 'written';
+    uid: number;
+    n: number;
+} | {
+    uplink: 'udp-opened';
+    uid: number;
+    cid: number;
+    localAddr: string;
+} | {
+    uplink: 'udp-sent';
+    uid: number;
+} | {
+    uplink: 'udp-message';
+    uid: number;
+    message: UplinkMessage | null;
+} | {
+    uplink: 'error';
+    uid: number;
+    message: string;
+    code?: string;
+};
+export interface UplinkPeer {
+    postMessage(message: UplinkReply, transfer?: Transferable[]): void;
+}
+export interface UplinkPort {
+    postMessage(message: UplinkCall, transfer?: Transferable[]): void;
+}
+export interface UplinkServer {
+    answer(call: UplinkCall): void;
+    close(): void;
+}
+export declare function answerOf(result: string[] | ResolveAnswer): ResolveAnswer;
+export declare function serveUplink(peer: UplinkPeer, uplink: NetworkUplink): UplinkServer;
+export declare class RemoteUplink implements NetworkUplink {
+    readonly traits: UplinkTraits;
+    readonly routes: RouteTable | undefined;
+    private readonly port;
+    private readonly waiting;
+    private nextId;
+    constructor(port: UplinkPort, traits: UplinkTraits, routes?: RouteTable);
+    receive(reply: UplinkReply): void;
+    private ask;
+    resolve(name: string, family: ResolveFamily, signal?: AbortSignal): Promise<ResolveAnswer>;
+    dial(req: UplinkDial): Promise<UplinkConn>;
+    udp(req: UplinkUdpOpen): Promise<UplinkUdp>;
+}

package/dist/types/kernel/net/ws-queue.d.ts

@@ -0,0 +1,21 @@
+import type { RealmWebSocketClose, RealmWebSocketMessage } from './transport.js';
+export declare const INBOUND_LIMIT: number;
+export declare const MESSAGE_LIMIT: number;
+export declare const TOO_BIG = 1009;
+export declare function payloadSize(message: RealmWebSocketMessage): number;
+export declare class MessageQueue implements AsyncIterable<RealmWebSocketMessage> {
+    private readonly items;
+    private readonly limit;
+    private waiter;
+    private size;
+    private ended;
+    private readonly overflow;
+    private readonly taken;
+    readonly closed: Promise<RealmWebSocketClose>;
+    private settle;
+    constructor(overflow: () => void, limit?: number, taken?: (n: number) => void);
+    push(message: RealmWebSocketMessage): void;
+    end(close: RealmWebSocketClose): void;
+    private wake;
+    [Symbol.asyncIterator](): AsyncIterator<RealmWebSocketMessage>;
+}

package/dist/types/kernel/net/ws-syscalls.d.ts

@@ -0,0 +1,45 @@
+import type { SyncFsResult } from '../../realm/sync-fs-wire.js';
+import type { KernelLoopback } from './loopback-transport.js';
+import type { HeaderList, RealmTransport } from './transport.js';
+export type WsSyscall = {
+    op: 'net-ws-open';
+    url: string;
+    protocols: string[];
+    headers: HeaderList;
+} | {
+    op: 'net-ws-ready';
+    handle: number;
+} | {
+    op: 'net-ws-recv';
+    handle: number;
+} | {
+    op: 'net-ws-wait';
+    handle: number;
+} | {
+    op: 'net-ws-send';
+    handle: number;
+    text?: string;
+    body?: Uint8Array;
+} | {
+    op: 'net-ws-close';
+    handle: number;
+    code?: number;
+    reason?: string;
+};
+export declare const WS_OPS: readonly string[];
+export declare class WsHandles {
+    private readonly transport;
+    private readonly open;
+    private readonly next;
+    private readonly local;
+    constructor(transport: RealmTransport, next: () => number, local?: KernelLoopback);
+    owns(handle: number): boolean;
+    syscall(req: WsSyscall): Promise<SyncFsResult>;
+    private start;
+    private connect;
+    private recv;
+    private closed;
+    private send;
+    close(handle: number): void;
+    closeAll(): void;
+}

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