@ai-ecoverse/slicc-kernel 1.181.0 → 1.183.0

package/dist/types/cdp/types.d.ts

@@ -1,3 +1,4 @@
+import type { ConnectorStamp } from '../kernel/socket.js';
 export interface CdpConnection {
     send(message: string): void;
     onmessage: ((message: string) => void) | null;
@@ -6,6 +7,7 @@ export interface CdpConnection {
 }
 export interface CdpRequest {
     runtime?: string;
+    stamp?: ConnectorStamp;
 }
 export type CdpHook = (request: CdpRequest) => Promise<CdpConnection>;
 export declare const CDP_PORT = 9222;

package/dist/types/client/attach.d.ts

@@ -2,6 +2,7 @@ import type { CdpHook } from '../cdp/types.js';
 import type { FacadeHook } from '../facade/types.js';
 import type { FsStat, UsersMode } from '../fs/types.js';
 import type { WatchChange } from '../fs/watch.js';
+import { type DeviceHook } from '../kernel/devices.js';
 import { type EmbedderHook } from '../kernel/embedder.js';
 import type { RealmTransport, RealmTransportRequest, RealmTransportResponse, RealmTransportTraits } from '../kernel/net/transport.js';
 import type { TraceEvent } from '../kernel/trace.js';
@@ -24,6 +25,7 @@ export interface AttachOptions {
     timeoutMs?: number;
     locks?: LockManagerLike | null;
     requests?: EmbedderHook;
+    devices?: DeviceHook;
 }
 export interface SpawnOptions {
     cwd?: string;

package/dist/types/client/protocol.d.ts

@@ -12,6 +12,7 @@ export interface ClientHello {
         group?: string;
         users?: Array<string | number>;
     }>;
+    devices?: true;
 }
 export interface KernelHello {
     protocol: readonly [number, number];

package/dist/types/client/serve-client.d.ts

@@ -12,6 +12,7 @@ export interface ClientHost {
     tag?: string;
     session?: number;
     attachRequests?: boolean;
+    attachDevices?: boolean;
 }
 export interface ServedClient {
     detach(kill?: boolean): void;

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

@@ -0,0 +1,74 @@
+import type { DeviceHook, DeviceStamp } from './kernel/devices.js';
+export interface DevicesPort {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+}
+interface Failure {
+    name: string;
+    message: string;
+}
+export type DevicesToPage = {
+    id: number;
+    open: {
+        client: number;
+        path: string;
+        flags: number;
+        stamp: DeviceStamp;
+    };
+} | {
+    id: number;
+    pull: true;
+} | {
+    id: number;
+    write: Uint8Array;
+    seq: number;
+} | {
+    id: number;
+    control: {
+        seq: number;
+        op: string;
+        args?: object;
+    };
+} | {
+    id: number;
+    cancel: string;
+};
+export type DevicesToKernel = {
+    id: number;
+    opened: true;
+} | {
+    id: number;
+    failed: Failure;
+} | {
+    id: number;
+    chunk: Uint8Array;
+} | {
+    id: number;
+    done: true;
+} | {
+    id: number;
+    readError: Failure;
+} | {
+    id: number;
+    wrote: number;
+} | {
+    id: number;
+    writeError: Failure;
+    seq: number;
+} | {
+    id: number;
+    answered: number;
+    value?: unknown;
+} | {
+    id: number;
+    refused: number;
+    error: Failure;
+};
+export declare function devicesAsker(port: DevicesPort): {
+    hookFor: (client: number) => DeviceHook;
+    answer: (message: DevicesToKernel) => void;
+};
+export declare function devicesAnswerer(port: DevicesPort, hookFor: (client: number) => DeviceHook | undefined): {
+    handle(data: unknown): boolean;
+};
+export declare function devicesReplyOf(data: unknown): DevicesToKernel | undefined;
+export {};

package/dist/types/index.d.ts

@@ -8,6 +8,7 @@ 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 DeviceHook, type DeviceSpec } from './kernel/devices.js';
 import { type EmbedderHook } from './kernel/embedder.js';
 import type { RouteTable } from './kernel/net/routes.js';
 import { type SealedOption } from './kernel/net/sealed-fetch.js';
@@ -26,6 +27,7 @@ export type { FacadeConnection, FacadeHook, FacadeInfo, FacadeSpec, FacadeSpecs,
 export type { Attestation, AttestedDir, AttestOptions, AttestTombstone } from './fs/attest.js';
 export type { Denial, DenialHook } from './fs/dac.js';
 export type { ClipboardHook, ClipboardStamp } from './kernel/clipboard.js';
+export type { DeviceHook, DeviceOpenRequest, DeviceSignals, DeviceSpec, DeviceStamp, DeviceStreams, } from './kernel/devices.js';
 export type { EmbedderHook, EmbedderKindPolicy, EmbedderReply, EmbedderRequest, EmbedderStamp, } from './kernel/embedder.js';
 export type { RouteTable } from './kernel/net/routes.js';
 export { SEALED_FETCH_VERSION, type SealedFetchHook, type SealedFetchRequest, type SealedOption, } from './kernel/net/sealed-fetch.js';
@@ -79,6 +81,7 @@ export interface KernelOptions {
     sealed?: SealedOption;
     clipboard?: ClipboardHook;
     requests?: EmbedderHook;
+    devices?: DeviceHook;
     approve?: ApproveHook;
     protect?: Protection;
 }
@@ -108,6 +111,16 @@ export interface ConnectOptions {
     user?: string | number;
     tag?: string;
     requests?: EmbedderHook | 'attach';
+    devices?: DeviceHook | 'attach';
+}
+export interface DeviceAddOptions extends DeviceSpec {
+    client?: MessagePort;
+}
+export interface DeviceNodeHandle {
+    remove(): Promise<void>;
+}
+export interface KernelDevices {
+    add(spec: DeviceAddOptions): Promise<DeviceNodeHandle>;
 }
 export interface KernelGroups {
     list(): Promise<Group[]>;
@@ -134,6 +147,7 @@ export interface Kernel {
     sudoRun(request: SudoReplay, options?: SudoRunOptions): Promise<SudoRun>;
     readonly users: KernelUsers;
     readonly groups: KernelGroups;
+    readonly devices: KernelDevices;
     setRoutes(routes: RouteTable): Promise<void>;
     chmod(path: string, mode: number): Promise<void>;
     readonly integrity: KernelIntegrity;

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

@@ -0,0 +1,155 @@
+import { type Guard } from '../fs/dac.js';
+import type { UsersMode } from '../fs/types.js';
+import { KernelError, type OpenAccess, OpenFile } from './fd-table.js';
+import { type SerialSettings, type SerialTermios } from './serial-ioctl.js';
+import { KernelTty, type Termios } from './tty.js';
+export declare const DEVICE_NAME: RegExp;
+export declare const BY_ID = "/dev/serial/by-id";
+export interface DeviceSignals {
+    clearToSend: boolean;
+    dataCarrierDetect: boolean;
+    dataSetReady: boolean;
+    ringIndicator: boolean;
+}
+export interface DeviceStreams {
+    readable: ReadableStream<Uint8Array>;
+    writable: WritableStream<Uint8Array>;
+    control(op: string, args?: object): unknown;
+}
+export interface DeviceStamp {
+    pid: number;
+    uid: number;
+    gid: number;
+    groups: number[];
+    users: UsersMode;
+    tag?: string;
+    tags?: string[];
+}
+export interface DeviceOpenRequest {
+    path: string;
+    flags: number;
+    stamp: DeviceStamp;
+    signal: AbortSignal;
+}
+export interface DeviceHook {
+    open(request: DeviceOpenRequest): DeviceStreams | Promise<DeviceStreams>;
+}
+export interface DeviceSpec {
+    path: string;
+    owner?: string | number;
+    group?: string | number;
+    mode?: number;
+    links?: readonly string[];
+}
+export interface DeviceNodeInfo {
+    path: string;
+    uid: number;
+    gid: number;
+    mode: number;
+    major: number;
+    minor: number;
+    links: string[];
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+}
+export interface DeviceMetaChange {
+    mode?: number;
+    uid?: number;
+    gid?: number;
+    atimeMs?: number | null;
+    mtimeMs?: number | null;
+    now?: boolean;
+}
+export interface DeviceLookup {
+    userId(name: string): Promise<number | undefined>;
+    groupId(name: string): Promise<number | undefined>;
+}
+interface DeviceState {
+    termios: Termios;
+    ispeed: number;
+    ospeed: number;
+}
+interface DeviceNode extends DeviceNodeInfo {
+    id: number;
+    client: number;
+    channel?: DeviceChannel;
+    opening: boolean;
+    saved?: DeviceState;
+}
+export interface DeviceOpener {
+    stamp: DeviceStamp;
+    guard?: Guard;
+    signal: AbortSignal;
+}
+export declare function devicesHook(hook: DeviceHook): DeviceHook;
+export declare class DeviceNodes {
+    private readonly hooks;
+    private readonly nodes;
+    private readonly links;
+    private readonly lookup;
+    readonly users: UsersMode;
+    private next;
+    constructor(users: UsersMode, lookup: DeviceLookup);
+    register(client: number, hook: DeviceHook): () => void;
+    add(spec: DeviceSpec, client: number): Promise<number>;
+    remove(id: number): boolean;
+    private drop;
+    list(): DeviceNodeInfo[];
+    meta(path: string, change: DeviceMetaChange, guard?: Guard): void;
+    find(path: string): DeviceNode | undefined;
+    openTty(path: string): KernelTty | undefined;
+    open(path: string, flags: number, opener: DeviceOpener): Promise<OpenFile>;
+}
+export declare class DeviceChannel {
+    readonly tty: KernelTty;
+    readonly path: string;
+    private readonly inner;
+    private readonly reader;
+    private readonly writer;
+    private readonly streams;
+    private readonly onClosed;
+    private readonly gone;
+    private failure;
+    private readonly pending;
+    private queued;
+    private resume;
+    private waiters;
+    private closed;
+    ispeed: number;
+    ospeed: number;
+    dtr: boolean;
+    rts: boolean;
+    constructor(path: string, streams: DeviceStreams, saved: DeviceState | undefined, onClosed: (state: DeviceState) => void);
+    file(access: OpenAccess): OpenFile;
+    lost(err: KernelError): void;
+    private control;
+    private buffered;
+    private pump;
+    private send;
+    private check;
+    private read;
+    private ready;
+    private write;
+    private poll;
+    private changed;
+    private wake;
+    drain(signal?: AbortSignal): Promise<void>;
+    restore(): Promise<void>;
+    settings(): SerialSettings;
+    termios(): SerialTermios;
+    setTermios(termios: SerialTermios, how: {
+        drain?: boolean;
+        flush?: boolean;
+        extended?: boolean;
+    }, signal?: AbortSignal): Promise<void>;
+    private bits;
+    modem(): Promise<number>;
+    setModem(bits: number): Promise<void>;
+    private signals;
+    sendBreak(ms: number, signal?: AbortSignal): Promise<void>;
+    flush(input: boolean, output: boolean): Promise<void>;
+    ioctl(request: number, arg: unknown, signal?: AbortSignal): Promise<unknown>;
+    close(): Promise<void>;
+}
+export {};

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

@@ -53,7 +53,9 @@ export interface EmbedderLookup {
     groupId(name: string): Promise<number | undefined>;
     userId(name: string): Promise<number | undefined>;
 }
+export declare function lineOf(err: unknown): string;
 export declare function embedderFailure(err: unknown): KernelError;
+export declare function interruptible<T>(work: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
 export declare class EmbedderChannel {
     readonly access: OpenAccess;
     readonly owner: number;

package/dist/types/kernel/fd-table.d.ts

@@ -1,9 +1,10 @@
 import type { ClipboardChannel } from './clipboard.js';
+import type { DeviceChannel } from './devices.js';
 import type { EmbedderChannel } from './embedder.js';
 import type { PtyPair } from './pty.js';
 import type { SealedChannel } from './sealed.js';
 import type { KernelTty } from './tty.js';
-export type KernelErrno = 'EBADF' | 'EPROTO' | 'EDEADLK' | 'ENOLCK' | 'EEXIST' | 'ELOOP' | 'EOVERFLOW' | 'ENAMETOOLONG' | 'EPIPE' | 'EMFILE' | 'EINVAL' | 'ENOENT' | 'ENOTDIR' | 'ENOEXEC' | 'ECHILD' | 'ENOSYS' | 'ESPIPE' | 'ENOSPC' | 'EINTR' | 'ESRCH' | 'ENOTTY' | 'ENXIO' | 'EPERM' | 'EIO' | 'EACCES' | 'EAGAIN' | 'ENOTSOCK' | 'EAFNOSUPPORT' | 'EPROTONOSUPPORT' | 'EPROTOTYPE' | 'EOPNOTSUPP' | 'EADDRINUSE' | 'EADDRNOTAVAIL' | 'ENETUNREACH' | 'ECONNREFUSED' | 'EINPROGRESS' | 'EISCONN' | 'ENOTCONN' | 'EROFS' | 'EFBIG' | 'EALREADY' | 'ETIMEDOUT' | 'ECONNABORTED' | 'EHOSTUNREACH' | 'ECONNRESET' | 'EMSGSIZE' | 'EDESTADDRREQ' | 'ENOPROTOOPT' | 'ENOTSUP' | 'EILSEQ';
+export type KernelErrno = 'EBADF' | 'EPROTO' | 'EDEADLK' | 'ENOLCK' | 'EEXIST' | 'ELOOP' | 'EOVERFLOW' | 'ENAMETOOLONG' | 'EPIPE' | 'EMFILE' | 'EINVAL' | 'ENOENT' | 'ENOTDIR' | 'ENOEXEC' | 'ECHILD' | 'ENOSYS' | 'ESPIPE' | 'ENOSPC' | 'EINTR' | 'ESRCH' | 'ENOTTY' | 'ENXIO' | 'EPERM' | 'EIO' | 'EACCES' | 'EAGAIN' | 'ENOTSOCK' | 'EAFNOSUPPORT' | 'EPROTONOSUPPORT' | 'EPROTOTYPE' | 'EOPNOTSUPP' | 'EADDRINUSE' | 'EADDRNOTAVAIL' | 'ENETUNREACH' | 'ECONNREFUSED' | 'EINPROGRESS' | 'EISCONN' | 'ENOTCONN' | 'EROFS' | 'EFBIG' | 'EALREADY' | 'ETIMEDOUT' | 'ECONNABORTED' | 'EHOSTUNREACH' | 'ECONNRESET' | 'EMSGSIZE' | 'EDESTADDRREQ' | 'ENOPROTOOPT' | 'ENOTSUP' | 'EILSEQ' | 'EBUSY';
 export declare class KernelError extends Error {
     readonly code: KernelErrno;
     readonly detail?: string;
@@ -41,6 +42,7 @@ export interface KernelFile {
     sealed?: SealedChannel;
     clipboard?: ClipboardChannel;
     embedder?: EmbedderChannel;
+    device?: DeviceChannel;
     held?: true;
     heldMeta?: HeldMeta;
     identity?: object;

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

@@ -7,6 +7,7 @@ import type { ChildForker, ChildSpawner } from './children.js';
 import type { ClipboardBroker } from './clipboard.js';
 import { type CpuTimes } from './cpu-clock.js';
 import { type Cred } from './cred.js';
+import type { DeviceNodes } from './devices.js';
 import type { EmbedderBroker } from './embedder.js';
 import { type FdTable, type OpenFile } from './fd-table.js';
 import type { FifoTable } from './fifo.js';
@@ -62,6 +63,7 @@ export interface SpawnWasmOptions {
             uid: number;
         };
     };
+    devices?: DeviceNodes;
     readonlyAt?: (path: string) => boolean;
     dac?: Dac;
     identity?: () => Promise<{

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

@@ -10,6 +10,7 @@ import { type SudoCall, type SudoResult, type SudoStdin, type VisudoCall, type V
 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 { DeviceMetaChange, DeviceNodes } from './devices.js';
 import { type EmbedderBroker } from './embedder.js';
 import { type EpollSyscall } from './epoll.js';
 import { type DeviceAccess, type FdTable, type HeldMeta, type KernelFdKind, type OpenFile } from './fd-table.js';
@@ -235,6 +236,20 @@ export type WasmSyscall = {
     op: 'fd-open-embedder';
     flags: number;
 } | {
+    op: 'fd-dev-nodes';
+} | {
+    op: 'fd-open-dev';
+    path: string;
+    flags: number;
+} | {
+    op: 'fd-dev-ioctl';
+    fd: number;
+    request: number;
+    arg?: unknown;
+} | ({
+    op: 'fd-dev-meta';
+    path: string;
+} & DeviceMetaChange) | {
     op: 'tty-get';
     fd: number;
 } | {
@@ -242,6 +257,7 @@ export type WasmSyscall = {
     fd: number;
     termios: Termios;
     flush?: boolean;
+    drain?: boolean;
 } | {
     op: 'tty-winsz';
     fd: number;
@@ -380,6 +396,7 @@ export interface WasmProcessOptions {
         uid: number;
     };
     embedderName?: string;
+    devices?: DeviceNodes;
     readonlyAt?: (path: string) => boolean;
     guard?: {
         dac: Dac;
@@ -521,6 +538,9 @@ export declare class WasmProcess {
     private complainLine;
     private embedderCaller;
     private closeFd;
+    private openDev;
+    private devMeta;
+    private devIoctl;
     private openEmbedder;
     complain(line: string): Promise<boolean>;
     private clipboardComplaint;

package/dist/types/kernel/serial-ioctl.d.ts

@@ -0,0 +1,73 @@
+import type { Termios } from './tty.js';
+export declare const IOCTL: {
+    readonly TCGETS: 21505;
+    readonly TCSETS: 21506;
+    readonly TCSETSW: 21507;
+    readonly TCSETSF: 21508;
+    readonly TCSBRK: 21513;
+    readonly TCFLSH: 21515;
+    readonly TIOCEXCL: 21516;
+    readonly TIOCNXCL: 21517;
+    readonly TIOCSCTTY: 21518;
+    readonly TIOCGPGRP: 21519;
+    readonly TIOCSPGRP: 21520;
+    readonly TIOCOUTQ: 21521;
+    readonly TIOCGWINSZ: 21523;
+    readonly TIOCSWINSZ: 21524;
+    readonly TIOCMGET: 21525;
+    readonly TIOCMBIS: 21526;
+    readonly TIOCMBIC: 21527;
+    readonly TIOCMSET: 21528;
+    readonly FIONREAD: 21531;
+    readonly TIOCNOTTY: 21538;
+    readonly TCSBRKP: 21541;
+    readonly TIOCSBRK: 21543;
+    readonly TIOCCBRK: 21544;
+    readonly TCGETS2: 2150388778;
+    readonly TCSETS2: 1076646955;
+    readonly TCSETSW2: 1076646956;
+    readonly TCSETSF2: 1076646957;
+};
+export declare const FILE_IOCTLS: ReadonlySet<number>;
+export declare const TERMIOS_GETS: ReadonlySet<number>;
+export declare const TERMIOS_SETS: ReadonlySet<number>;
+export declare const INT_OUT: ReadonlySet<number>;
+export declare const INT_IN: ReadonlySet<number>;
+export declare const INT_ARG: ReadonlySet<number>;
+export declare const TIOCM: {
+    readonly DTR: 2;
+    readonly RTS: 4;
+    readonly CTS: 32;
+    readonly CD: 64;
+    readonly RI: 128;
+    readonly DSR: 256;
+};
+export interface SerialTermios extends Termios {
+    c_ispeed?: number;
+    c_ospeed?: number;
+}
+export interface SerialSettings {
+    baudRate: number;
+    dataBits: number;
+    parity: 'none' | 'even' | 'odd';
+    stopBits: 1 | 2;
+    flowControl: 'none' | 'hardware';
+}
+export declare const CBAUD = 4111;
+export declare const BOTHER = 4096;
+export declare function speedOf(code: number): number | undefined;
+export declare function codeOf(speed: number): number;
+export declare function speedsOf(termios: SerialTermios, current: {
+    ispeed: number;
+    ospeed: number;
+}, extended: boolean): {
+    ispeed: number;
+    ospeed: number;
+};
+export declare function settingsOf(cflag: number, baudRate: number): SerialSettings;
+export declare function sameSettings(a: SerialSettings, b: SerialSettings): boolean;
+export declare const SERIAL_CFLAG: number;
+export declare const SERIAL_LFLAG: number;
+export declare const SERIAL_OFLAG = 4;
+export declare function ioctlArg(view: DataView, request: number, arg: number): unknown;
+export declare function ioctlResult(view: DataView, request: number, arg: number, result: unknown): void;

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

@@ -142,6 +142,7 @@ export declare class LoopbackNet {
     private readonly reserved;
     private readonly facades;
     private proxyStamped;
+    private readonly stamped;
     private nextEphemeral;
     private route;
     private origins;
@@ -162,6 +163,7 @@ export declare class LoopbackNet {
     kernelOnly(port: number, reserve?: boolean): boolean;
     reserve(port: number): void;
     facade(port: number, name: string): void;
+    stampPeers(port: number): void;
     stampProxy(port: number): void;
     get originsStamped(): boolean;
     stampsPeers(addr: SockAddr): boolean;

package/dist/types/launcher.d.ts

@@ -12,6 +12,7 @@ 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 DeviceHook, DeviceNodes } from './kernel/devices.js';
 import { EmbedderBroker, type EmbedderHook } from './kernel/embedder.js';
 type EmbedderSession = {
     client: number;
@@ -75,6 +76,7 @@ export interface LauncherOptions {
     sealedFetch?: SealedFetchHook;
     clipboard?: ClipboardHook;
     embedder?: EmbedderHook;
+    devices?: DeviceHook;
     approve?: ApproveHook;
     sudoTimeoutMs?: number;
     sudoClock?: {
@@ -295,6 +297,7 @@ export declare class Launcher {
     private readonly scrubs;
     private readonly clipboard;
     readonly embedder: EmbedderBroker;
+    readonly devices: DeviceNodes;
     private readonly rootFs;
     private fileWatches;
     private nextPid;
@@ -457,6 +460,7 @@ export declare class Launcher {
     private imageOf;
     credOf(pid: number): Cred;
     private wireSealed;
+    private deviceNodes;
     private embedderBroker;
     sessionOf(pid: number): EmbedderSession;
     tagOf(pid: number): string | undefined;

package/dist/types/node.d.ts

@@ -7,8 +7,9 @@ import type { Attestation, AttestTombstone } 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 { ConnectOptions, KernelGroups, KernelIntegrity, KernelSealed, KernelUsers, RunOptions, RunResult, Terminal, TerminalOptions } from './index.js';
+import type { ConnectOptions, KernelDevices, KernelGroups, KernelIntegrity, KernelSealed, KernelUsers, RunOptions, RunResult, Terminal, TerminalOptions } from './index.js';
 import type { ClipboardHook } from './kernel/clipboard.js';
+import { type DeviceHook } from './kernel/devices.js';
 import { type EmbedderHook } from './kernel/embedder.js';
 import type { RouteTable } from './kernel/net/routes.js';
 import { type SealedOption } from './kernel/net/sealed-fetch.js';
@@ -25,8 +26,9 @@ export { type AttachOptions, attachKernel, type ClientEnded, type ClientFetchReq
 export type { FacadeConnection, FacadeHook, FacadeInfo, FacadeSpec, FacadeSpecs, } from './facade/types.js';
 export type { Attestation, AttestedDir, AttestOptions, AttestTombstone } from './fs/attest.js';
 export type { Denial, DenialHook } from './fs/dac.js';
-export type { ConnectOptions, CwdMissing, Ended, KernelGroups, KernelIntegrity, KernelSealed, KernelUsers, NetworkUplink, ResolveAnswer, ResolveFamily, RouteTable, RunOptions, RunResult, Terminal, TerminalOptions, TerminalSignal, } from './index.js';
+export type { ConnectOptions, CwdMissing, DeviceAddOptions, DeviceNodeHandle, Ended, KernelDevices, KernelGroups, KernelIntegrity, KernelSealed, KernelUsers, NetworkUplink, ResolveAnswer, ResolveFamily, RouteTable, RunOptions, RunResult, Terminal, TerminalOptions, TerminalSignal, } from './index.js';
 export type { ClipboardHook, ClipboardStamp } from './kernel/clipboard.js';
+export type { DeviceHook, DeviceOpenRequest, DeviceSignals, DeviceSpec, DeviceStamp, DeviceStreams, } from './kernel/devices.js';
 export type { EmbedderHook, EmbedderKindPolicy, EmbedderReply, EmbedderRequest, EmbedderStamp, } from './kernel/embedder.js';
 export { SEALED_FETCH_VERSION, type SealedFetchHook, type SealedFetchRequest, type SealedOption, } from './kernel/net/sealed-fetch.js';
 export type { SealedAbortReason, SealedCaller, SealedHook, SealedRequest, SealedRequester, } from './kernel/sealed.js';
@@ -67,6 +69,7 @@ export interface NodeKernelOptions {
     sealed?: SealedOption;
     clipboard?: ClipboardHook;
     requests?: EmbedderHook;
+    devices?: DeviceHook;
     approve?: ApproveHook;
     protect?: Protection;
     cron?: {
@@ -104,6 +107,7 @@ export interface NodeKernel {
     sudoRun(request: SudoReplay, options?: SudoRunOptions): Promise<SudoRun>;
     readonly users: KernelUsers;
     readonly groups: KernelGroups;
+    readonly devices: KernelDevices;
     setRoutes(routes: RouteTable): Promise<void>;
     updateTransportTraits(): Promise<boolean>;
     mount(spec: MountSpec): Promise<MountEntry>;

package/dist/types/process/js/js-dev.d.ts

@@ -17,6 +17,7 @@ export interface DevOpened {
     file: boolean;
     read: boolean;
     write: boolean;
+    device?: boolean;
 }
 export declare function devOpen(abs: string, o: JsOpenOptions): DevStep<DevOpened>;
 export declare function devAsync<T>(kernel: {
@@ -29,15 +30,38 @@ export interface StreamIo {
     read(fd: number, max: number): Promise<Uint8Array>;
     write(fd: number, data: Uint8Array): Promise<void>;
     close(fd: number): Promise<void>;
+    ioctl?(fd: number, request: number, arg?: unknown): Promise<unknown>;
 }
 export interface StreamSyncIo {
     read(fd: number, max: number): Uint8Array;
     write(fd: number, data: Uint8Array): void;
     close(fd: number): void;
+    ioctl?(fd: number, request: number, arg?: unknown): unknown;
 }
+export declare function ioctlRequest(fd: number, request: number, arg?: unknown): SyncSabRequestBody;
+export interface JsSerialTermios {
+    c_iflag: number;
+    c_oflag: number;
+    c_cflag: number;
+    c_lflag: number;
+    c_cc: number[];
+    ispeed: number;
+    ospeed: number;
+}
+export interface JsModem {
+    dtr: boolean;
+    rts: boolean;
+    cts: boolean;
+    dsr: boolean;
+    cd: boolean;
+    ri: boolean;
+}
+export type JsTermiosWhen = 'now' | 'drain' | 'flush';
+export type JsFlushQueue = 'input' | 'output' | 'both';
 export interface StreamAccess {
     read: boolean;
     write: boolean;
+    device?: boolean;
 }
 export declare function streamFile(fd: number, path: string, io: StreamIo, access: StreamAccess): {
     file: JsFile;

package/dist/types/process/kernel-streams.d.ts

@@ -1,3 +1,4 @@
+import type { DeviceMetaChange, DeviceNodeInfo } from '../kernel/devices.js';
 import type { HeldMeta, PollState } from '../kernel/fd-table.js';
 import type { MountLine, ProcessListing } from '../kernel/proc-info.js';
 import type { Termios } from '../kernel/tty.js';
@@ -56,7 +57,11 @@ export interface ProcessSys {
     ttyNames?(): string[];
     ttyOwner?(name: string): TtyOwner | null;
     tcgets?(fd: number): Termios;
-    tcsets?(fd: number, termios: Termios, flush?: boolean): void;
+    tcsets?(fd: number, termios: Termios, flush?: boolean, drain?: boolean): void;
+    devNodes?(): DeviceNodeInfo[];
+    openDev?(path: string, flags: number): number;
+    devIoctl?(fd: number, request: number, arg?: unknown): unknown;
+    devMeta?(path: string, change: DeviceMetaChange): void;
     winsize?(fd: number): [number, number];
     openPty?(): number;
     openPts?(n: number, noctty: boolean): number;
@@ -87,6 +92,7 @@ export interface ProcessStream {
     sliccCloexec?: boolean;
     sliccKernelSocket?: boolean;
     sliccKernelFifo?: string;
+    sliccDevice?: boolean;
     path?: string;
     flags: number;
     position: number;
@@ -174,6 +180,10 @@ export declare class KernelStreams {
     private creatingTerminal;
     private useTerminalNodes;
     private usePtsNodes;
+    private useDeviceNodes;
+    private useDeviceMeta;
+    private liveDeviceStat;
+    private openDeviceNode;
     private ptyNode;
     private ptsTarget;
     private ttyNode;