@ai-ecoverse/slicc-kernel 1.102.6 → 1.103.0

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

@@ -0,0 +1,63 @@
+import type { SyncFsResult } from '../../realm/sync-fs-wire.js';
+import type { SyncSabRequestBody } from '../../realm/sync-sab-wire.js';
+import { type JsKernel } from './js-kernel.js';
+export interface SyncSpawnKernel {
+    json(req: SyncSabRequestBody): unknown;
+    raw(req: SyncSabRequestBody): SyncFsResult;
+}
+export type JsStdio = 'inherit' | 'pipe' | 'null' | number;
+export interface JsSpawnOptions {
+    argv: readonly string[];
+    argv0?: string;
+    env?: Readonly<Record<string, string>>;
+    cwd?: string;
+    pgid?: number;
+    session?: boolean;
+    parentDeathSignal?: number | `SIG${string}`;
+    stdin?: JsStdio;
+    stdout?: JsStdio;
+    stderr?: JsStdio;
+}
+export interface JsExited {
+    status: number;
+    signal?: number;
+    stopped?: true;
+}
+export interface JsWaitOptions {
+    untraced?: boolean;
+}
+export interface JsChild {
+    readonly pid: number;
+    readonly stdin?: WritableStream<Uint8Array>;
+    readonly stdout?: ReadableStream<Uint8Array>;
+    readonly stderr?: ReadableStream<Uint8Array>;
+    wait(options?: JsWaitOptions): Promise<JsExited>;
+    kill(signal?: number | `SIG${string}`): Promise<void>;
+}
+export interface ChildIo {
+    read(fd: number, max: number | undefined, signal: AbortSignal): Promise<Uint8Array>;
+    send(fd: number, data: Uint8Array, signal: AbortSignal): Promise<void>;
+    close(fd: number): Promise<void>;
+}
+export interface ChildDefaults {
+    env: Readonly<Record<string, string>>;
+    cwd: string;
+    signal(name: number | `SIG${string}`): number;
+}
+export declare function exitedOf(status: number): JsExited;
+export declare function childOps(kernel: JsKernel, io: ChildIo, defaults: ChildDefaults, sync: SyncSpawnKernel): {
+    spawn: (o: JsSpawnOptions) => Promise<JsChild>;
+    wait: (pid: number, options?: JsWaitOptions) => Promise<JsExited>;
+    kill: (pid: number, signal?: number | `SIG${string}`) => Promise<void>;
+    spawnSync: (o: JsSpawnOptions) => JsChild;
+};
+export declare function groupOf(o: {
+    pgid?: number;
+    session?: boolean;
+}, call: string): {
+    pgid?: number;
+    session?: true;
+};
+export declare function argv0Of(argv0: unknown, call: string): {
+    argv0?: string;
+};

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

@@ -0,0 +1,133 @@
+import { type SyncFsBridgeStat } from '../../realm/sync-fs-wire.js';
+import { type JsChild, type JsExited, type JsSpawnOptions, type JsWaitOptions } from './js-children.js';
+import { type JsFdType, type JsOpenOptions, type JsStatFs } from './js-io.js';
+import { type JsKernel } from './js-kernel.js';
+import { type JsNet } from './js-net.js';
+import { type JsSyncContext, type SyncCall } from './js-sync.js';
+import { type JsTty } from './js-tty.js';
+import { type JsWebSocket, type JsWebSocketOptions } from './js-websocket.js';
+export type { JsFdType, JsOpenOptions } from './js-io.js';
+export interface JsFile {
+    readonly fd: number;
+    readonly path: string;
+    size(): Promise<number>;
+    read(position: number, length: number): Promise<Uint8Array>;
+    write(position: number, data: Uint8Array): Promise<number>;
+    truncate(size: number): Promise<void>;
+    sync(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface JsFdStatus {
+    type: JsFdType;
+    tty: boolean;
+    seekable: boolean;
+}
+export type JsSignal = number | `SIG${string}`;
+export interface JsKernelInfo {
+    readonly version: string;
+}
+export declare const KERNEL_INFO: JsKernelInfo;
+export interface JsProgramContext {
+    readonly kernel: JsKernelInfo;
+    readonly argv: readonly string[];
+    readonly env: Readonly<Record<string, string>>;
+    readonly pid: number;
+    ppid(): Promise<number>;
+    readonly cwd: string;
+    readonly stdin: ReadableStream<Uint8Array>;
+    readonly stdout: WritableStream<Uint8Array>;
+    readonly stderr: WritableStream<Uint8Array>;
+    read(fd: number, max?: number): Promise<Uint8Array>;
+    write(fd: number, data: Uint8Array | string): Promise<void>;
+    close(fd: number): Promise<void>;
+    fdStatus(fd: number): Promise<JsFdStatus>;
+    isatty(fd: number): Promise<boolean>;
+    open(path: string, options?: JsOpenOptions): Promise<JsFile>;
+    resolve(path: string): string;
+    fs: {
+        stat(path: string): Promise<SyncFsBridgeStat>;
+        lstat(path: string): Promise<SyncFsBridgeStat>;
+        exists(path: string): Promise<boolean>;
+        readdir(path: string): Promise<string[]>;
+        mkdir(path: string, options?: {
+            recursive?: boolean;
+            mode?: number;
+        }): Promise<void>;
+        rm(path: string): Promise<void>;
+        unlink(path: string): Promise<void>;
+        rename(from: string, to: string): Promise<void>;
+        chmod(path: string, mode: number): Promise<void>;
+        link(from: string, to: string): Promise<void>;
+        symlink(target: string, path: string): Promise<void>;
+        readlink(path: string): Promise<string>;
+        statfs(path: string): Promise<JsStatFs>;
+        readFile(path: string): Promise<Uint8Array>;
+        writeFile(path: string, data: Uint8Array | string, options?: {
+            mode?: number;
+        }): Promise<void>;
+    };
+    signals: {
+        on(signal: JsSignal, handler: (signal: number) => void): Promise<void>;
+        ignore(signal: JsSignal): Promise<void>;
+        reset(signal: JsSignal): Promise<void>;
+    };
+    sync: JsSyncContext;
+    spawn(options: JsSpawnOptions): Promise<JsChild>;
+    wait(pid: number, options?: JsWaitOptions): Promise<JsExited>;
+    kill(pid: number, signal?: JsSignal): Promise<void>;
+    sudo(args: readonly string[]): Promise<JsSudoAnswer>;
+    umask(mask?: number): Promise<number>;
+    net: JsNet;
+    websocket(url: string | URL, options?: JsWebSocketOptions): Promise<JsWebSocket>;
+    tty: JsTty;
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    exit(code?: number): never;
+    onUncaught(listener: JsStrayListener): () => void;
+    onUnhandledRejection(listener: JsStrayListener): () => void;
+}
+export type JsSudoAnswer = {
+    error: string;
+    errno: string;
+} | {
+    list: string;
+} | {
+    run: string[];
+} | {
+    pid: number;
+};
+export type JsStrayListener = (error: unknown, promise?: Promise<unknown>) => void;
+export interface JsStrays {
+    exception: Set<JsStrayListener>;
+    rejection: Set<JsStrayListener>;
+}
+export declare class JsExit extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+export interface ContextOptions {
+    kernel: JsKernel;
+    argv: readonly string[];
+    env: Readonly<Record<string, string>>;
+    pid: number;
+    ppid: number;
+    cwd: string;
+    exit(status: number): void;
+    random?: (bytes: Uint8Array) => void;
+    lane?: SyncCall;
+    strays?: JsStrays;
+}
+export interface Identity {
+    pid: number;
+    ppid: number;
+}
+export declare function identityOf(answer: unknown, fallback: {
+    pid: number;
+    ppid?: number;
+}): Identity;
+export declare function signalNumber(signal: JsSignal): number;
+export declare function resolvePath(cwd: string, path: string): string;
+export interface CreatedContext {
+    ctx: JsProgramContext;
+    drain(): Promise<unknown>;
+}
+export declare function createContext(o: ContextOptions): CreatedContext;

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

@@ -0,0 +1,50 @@
+import { type SyncFsBridgeStat } from '../../realm/sync-fs-wire.js';
+import type { SyncSabRequestBody } from '../../realm/sync-sab-wire.js';
+import type { JsFile } from './js-context.js';
+import { type JsOpenOptions } from './js-io.js';
+import type { JsSyncFile } from './js-sync.js';
+export type DevStep<T> = Generator<SyncSabRequestBody, T, unknown>;
+export declare const DEV_READ_MAX: number;
+export declare function inDev(abs: string): boolean;
+export declare function devStat(abs: string, follow: boolean): DevStep<SyncFsBridgeStat>;
+export declare function devExists(abs: string): DevStep<boolean>;
+export declare function devReadlink(abs: string): DevStep<string>;
+export declare function devResolveTarget(abs: string): DevStep<string | undefined>;
+export declare function devReaddir(abs: string): DevStep<string[]>;
+export interface DevOpened {
+    fd: number;
+    file: boolean;
+    read: boolean;
+    write: boolean;
+}
+export declare function devOpen(abs: string, o: JsOpenOptions): DevStep<DevOpened>;
+export declare function devAsync<T>(kernel: {
+    json(req: SyncSabRequestBody): Promise<unknown>;
+}, step: DevStep<T>): Promise<T>;
+export declare function devSync<T>(kernel: {
+    json(req: SyncSabRequestBody): unknown;
+}, step: DevStep<T>): T;
+export interface StreamIo {
+    read(fd: number, max: number): Promise<Uint8Array>;
+    write(fd: number, data: Uint8Array): Promise<void>;
+    close(fd: number): Promise<void>;
+}
+export interface StreamSyncIo {
+    read(fd: number, max: number): Uint8Array;
+    write(fd: number, data: Uint8Array): void;
+    close(fd: number): void;
+}
+export interface StreamAccess {
+    read: boolean;
+    write: boolean;
+}
+export declare function streamFile(fd: number, path: string, io: StreamIo, access: StreamAccess): {
+    file: JsFile;
+    invalidate: () => void;
+};
+export declare function streamSyncFile(fd: number, path: string, io: StreamSyncIo, access: StreamAccess): {
+    file: JsSyncFile;
+    invalidate: () => void;
+};
+export declare function readWhole(file: JsFile): Promise<Uint8Array>;
+export declare function readWholeSync(file: JsSyncFile): Uint8Array;

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

@@ -0,0 +1,15 @@
+import type { SyncSabRequestBody } from '../../realm/sync-sab-wire.js';
+import type { SyncCall } from './js-sync.js';
+export interface PendingWrite {
+    fd: number;
+    data: Uint8Array;
+    at: number;
+    len: number;
+    op?: number;
+}
+export interface SavedMode {
+    terminal: string;
+    fd: number;
+    termios: unknown;
+}
+export declare function exitAtOnce(lane: SyncCall, writes: readonly PendingWrite[], modes: readonly SavedMode[], status: number, last?: SyncSabRequestBody): never;

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

@@ -0,0 +1,2 @@
+import { type JsKernel } from './js-kernel.js';
+export declare function fetchOp(kernel: JsKernel): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

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

@@ -0,0 +1,81 @@
+import type { DeviceMeta, KernelFdKind } from '../../kernel/fd-table.js';
+import { type SyncFsBridgeStat, type SyncFsResult } from '../../realm/sync-fs-wire.js';
+export interface JsOpenOptions {
+    read?: boolean;
+    write?: boolean;
+    append?: boolean;
+    create?: boolean;
+    exclusive?: boolean;
+    truncate?: boolean;
+    mode?: number;
+}
+export type JsFdType = 'file' | 'pipe' | 'tty' | 'socket' | 'device' | 'directory';
+export interface FdInfo {
+    tty?: boolean;
+    kind?: KernelFdKind;
+    meta?: DeviceMeta | {
+        dir: string;
+    };
+    terminal?: string;
+    access?: 'read' | 'write';
+}
+export declare const CHUNK: number;
+export declare const MAX_IO: number;
+export declare function typeOf(info: FdInfo): JsFdType;
+export declare function readDevice(info: FdInfo, max: number, random: (bytes: Uint8Array) => void): Uint8Array | undefined;
+export declare function writeDevice(info: FdInfo): boolean;
+export declare function brokenPipe(err: unknown, info: FdInfo): boolean;
+export declare function written(r: SyncFsResult, fallback: number): number;
+export interface JsStatFs {
+    type: number;
+    bsize: number;
+    blocks: number;
+    bfree: number;
+    bavail: number;
+    files: number;
+    ffree: number;
+    quota: number;
+    usage: number;
+}
+export declare function statFsOf(json: unknown): JsStatFs;
+export declare function joined(parts: Uint8Array[], length: number): Uint8Array;
+export declare function fileWrite(fd: number, append: boolean, offset: number, body: Uint8Array): {
+    op: 'fd-write';
+    fd: number;
+    body: Uint8Array<ArrayBufferLike>;
+    offset?: undefined;
+} | {
+    op: 'fd-pwrite';
+    fd: number;
+    offset: number;
+    body: Uint8Array<ArrayBufferLike>;
+};
+export declare function isExclusive(o: JsOpenOptions): boolean;
+export declare function absent(err: unknown): undefined;
+export declare function checkOpen(abs: string, o: JsOpenOptions, existing?: SyncFsBridgeStat): void;
+export declare function openRequest(abs: string, o: JsOpenOptions): {
+    op: 'fd-open-vfs';
+    path: string;
+    flags: number;
+    position: number;
+    exclusive: boolean;
+    truncate?: boolean | undefined;
+    mode?: number | undefined;
+} | {
+    op: 'fd-open-vfs';
+    path: string;
+    flags: number;
+    position: number;
+    create: boolean;
+    truncate?: boolean | undefined;
+    mode?: number | undefined;
+} | {
+    op: 'fd-open-vfs';
+    path: string;
+    flags: number;
+    position: number;
+    existing: boolean;
+    truncate?: boolean | undefined;
+    mode?: number | undefined;
+};
+export declare function index(n: number, what: string): void;

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

@@ -0,0 +1,61 @@
+import type { WasmSyscall } from '../../kernel/process.js';
+import { type DefaultAction } from '../../kernel/signals.js';
+import type { SyncFsResult } from '../../realm/sync-fs-wire.js';
+import { type SyncSabRequestBody } from '../../realm/sync-sab-wire.js';
+import { type AsyncSabTransport, type WaitAsyncLike } from './async-sab.js';
+export declare class JsCallError extends Error {
+    readonly code: string;
+    constructor(code: string, what: string);
+}
+export declare function umaskRequest(mask: unknown): {
+    op: 'proc-umask';
+    mask?: number;
+};
+export declare function modeOf(mode: unknown): number;
+export declare function callError(result: {
+    errno: string;
+    message: string;
+}, op: string): JsCallError;
+export type SignalHandler = (signal: number) => unknown;
+export interface JsKernelOptions {
+    sab: SharedArrayBuffer;
+    transport: AsyncSabTransport;
+    waitAsync: WaitAsyncLike | undefined;
+    onError: (err: unknown) => void;
+}
+export declare class JsKernel {
+    private readonly header;
+    private readonly transport;
+    private readonly waitAsync;
+    private readonly onError;
+    private handlers;
+    private ignored;
+    private changing;
+    pid: number;
+    private reported;
+    private watching;
+    faulted: boolean;
+    syncLane: ((req: SyncSabRequestBody) => SyncFsResult) | undefined;
+    constructor(o: JsKernelOptions);
+    raw(req: SyncSabRequestBody): Promise<SyncFsResult>;
+    call(req: SyncSabRequestBody): Promise<SyncFsResult>;
+    json(req: SyncSabRequestBody): Promise<unknown>;
+    bytes(req: SyncSabRequestBody): Promise<Uint8Array>;
+    blocking(req: WasmSyscall, signal?: AbortSignal, track?: (id: number) => void): Promise<SyncFsResult>;
+    private acks;
+    ack(id: number): void;
+    private submit;
+    private settled;
+    deliver(): void;
+    private fault;
+    watch(): Promise<void>;
+    watchStops(): Promise<void>;
+    freeze(): void;
+    disposition(sig: number): 'caught' | 'ignored' | DefaultAction;
+    setHandler(sig: number, handler: SignalHandler | 'ignore' | 'default'): Promise<void>;
+    private changeNow;
+    private disposed;
+    private change;
+    private raise;
+    private report;
+}

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

@@ -0,0 +1,42 @@
+import { type JsKernel } from './js-kernel.js';
+export interface JsAddress {
+    host: string;
+    port: number;
+}
+export interface JsConnection {
+    readonly fd: number;
+    readonly local: JsAddress;
+    readonly remote: JsAddress;
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Uint8Array>;
+    close(): Promise<void>;
+}
+export interface JsListener extends AsyncIterable<JsConnection> {
+    readonly fd: number;
+    readonly host: string;
+    readonly port: number;
+    accept(options?: {
+        signal?: AbortSignal;
+    }): Promise<JsConnection>;
+    close(): Promise<void>;
+}
+export interface JsListenOptions {
+    port?: number;
+    host?: string;
+    backlog?: number;
+}
+export interface JsConnectOptions {
+    host?: string;
+    port: number;
+    signal?: AbortSignal;
+}
+export interface JsNet {
+    listen(options?: JsListenOptions): Promise<JsListener>;
+    connect(options: JsConnectOptions): Promise<JsConnection>;
+}
+export interface NetIo {
+    read(fd: number, max: number | undefined, signal: AbortSignal): Promise<Uint8Array>;
+    send(fd: number, data: Uint8Array, signal: AbortSignal): Promise<void>;
+    close(fd: number): Promise<void>;
+}
+export declare function netOps(kernel: JsKernel, io: NetIo): JsNet;

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

@@ -0,0 +1,31 @@
+import type { SyncSabRequestBody } from '../../realm/sync-sab-wire.js';
+import { inProc, ProcTree } from '../wasi/wasi-procfs.js';
+import { type DevStep } from './js-dev.js';
+export { inProc };
+export declare function procStep<T>(abs: string, pid: number, run: (tree: ProcTree) => T): DevStep<T>;
+export declare function readOnly(path: string): never;
+export interface ProcOpenOptions {
+    write?: boolean;
+    append?: boolean;
+    create?: boolean;
+    truncate?: boolean;
+    exclusive?: boolean;
+}
+export declare function procWrites(options: ProcOpenOptions | undefined): boolean;
+type ProcRun = <T>(step: DevStep<T>) => T | Promise<T>;
+interface ProcPaths {
+    resolve: (path: string) => string;
+    pid: number;
+}
+export declare function withProc<F extends Record<string, unknown>>(fs: F, paths: ProcPaths, run: ProcRun): F;
+export declare function procOpen<O, R>(open: (path: string, options?: O) => R, paths: ProcPaths, run: ProcRun, async?: boolean): (path: string, options?: O) => R;
+type Lane = {
+    json(req: SyncSabRequestBody): unknown;
+};
+type AsyncLane = {
+    json(req: SyncSabRequestBody): Promise<unknown>;
+};
+export declare function procFsAsync<F extends object>(fs: F, kernel: AsyncLane, paths: ProcPaths): F;
+export declare function procFsSync<F extends object>(fs: F, kernel: Lane, paths: ProcPaths): F;
+export declare function procOpenAsync<O, R>(open: (path: string, options?: O) => R, kernel: AsyncLane, paths: ProcPaths): (path: string, options?: O | undefined) => R;
+export declare function procOpenSync<O, R>(open: (path: string, options?: O) => R, kernel: Lane, paths: ProcPaths): (path: string, options?: O | undefined) => R;

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

@@ -0,0 +1,35 @@
+import type { JsSyncKernel } from './js-sync.js';
+export type JsRunStdio = 'pipe' | 'ignore' | 'inherit' | number;
+export interface JsRunOptions {
+    argv: readonly string[];
+    argv0?: string;
+    env?: Readonly<Record<string, string>>;
+    cwd?: string;
+    pgid?: number;
+    session?: boolean;
+    input?: Uint8Array | string;
+    stdin?: JsRunStdio;
+    stdout?: JsRunStdio;
+    stderr?: JsRunStdio | 'stdout';
+    maxBuffer?: number;
+    timeout?: number;
+    killSignal?: number | `SIG${string}`;
+}
+export interface JsRunResult {
+    pid: number;
+    status: number | null;
+    signal?: number;
+    stdout?: Uint8Array;
+    stderr?: Uint8Array;
+    error?: {
+        code: string;
+    };
+}
+export interface RunDefaults {
+    env: Readonly<Record<string, string>>;
+    cwd: string;
+    resolve(path: string): string;
+    signal(name: number | `SIG${string}`): number;
+}
+export declare function decodeRun(bytes: Uint8Array, stdout: JsRunStdio, stderr: JsRunStdio | 'stdout'): JsRunResult;
+export declare function runSync(kernel: JsSyncKernel, d: RunDefaults, o: JsRunOptions): JsRunResult;

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

@@ -0,0 +1,86 @@
+import type { JsLane } from '../../kernel/protocol.js';
+import { type SyncFsBridgeStat, type SyncFsResult } from '../../realm/sync-fs-wire.js';
+import type { SyncSabRequestBody } from '../../realm/sync-sab-wire.js';
+import type { JsChild, JsSpawnOptions } from './js-children.js';
+import { type FdInfo, type JsOpenOptions, type JsStatFs } from './js-io.js';
+import { type JsKernel } from './js-kernel.js';
+import type { JsRunOptions, JsRunResult } from './js-run.js';
+export type SyncCall = (req: SyncSabRequestBody) => SyncFsResult;
+export interface JsSyncFile {
+    readonly fd: number;
+    readonly path: string;
+    size(): number;
+    read(position: number, length: number): Uint8Array;
+    write(position: number, data: Uint8Array): number;
+    truncate(size: number): void;
+    sync(): void;
+    close(): void;
+}
+export interface JsCred {
+    ruid: number;
+    euid: number;
+    suid: number;
+    rgid: number;
+    egid: number;
+    sgid: number;
+    groups: number[];
+}
+export interface JsSyncContext {
+    readonly kernel: {
+        readonly version: string;
+    };
+    run(options: JsRunOptions): JsRunResult;
+    spawn(options: JsSpawnOptions): JsChild;
+    exit(status?: number): never;
+    kill(pid: number, signal?: number | `SIG${string}`): void;
+    cred(): JsCred;
+    umask(mask?: number): number;
+    setcred(change: Partial<JsCred>): JsCred;
+    read(fd: number, max?: number): Uint8Array;
+    write(fd: number, data: Uint8Array | string): void;
+    close(fd: number): void;
+    open(path: string, options?: JsOpenOptions): JsSyncFile;
+    fs: {
+        stat(path: string): SyncFsBridgeStat;
+        lstat(path: string): SyncFsBridgeStat;
+        exists(path: string): boolean;
+        readdir(path: string): string[];
+        mkdir(path: string, options?: {
+            recursive?: boolean;
+            mode?: number;
+        }): void;
+        rm(path: string): void;
+        unlink(path: string): void;
+        rename(from: string, to: string): void;
+        chmod(path: string, mode: number): void;
+        link(from: string, to: string): void;
+        symlink(target: string, path: string): void;
+        readlink(path: string): string;
+        statfs(path: string): JsStatFs;
+        readFile(path: string): Uint8Array;
+        writeFile(path: string, data: Uint8Array | string, options?: {
+            mode?: number;
+        }): void;
+    };
+}
+export interface SyncShared {
+    pid: number;
+    resolve(path: string): string;
+    random(bytes: Uint8Array): void;
+    infos: Map<number, FdInfo>;
+    handles: Map<number, () => void>;
+}
+export declare const noLane: SyncCall;
+export declare function laneOf(lane: JsLane | undefined): SyncCall;
+export declare class JsSyncKernel {
+    private readonly lane;
+    private readonly kernel;
+    private readonly unwind;
+    constructor(lane: SyncCall, kernel: Pick<JsKernel, 'deliver'>, unwind?: () => void);
+    raw(req: SyncSabRequestBody): SyncFsResult;
+    call(req: SyncSabRequestBody): SyncFsResult;
+    json(req: SyncSabRequestBody): unknown;
+    bytes(req: SyncSabRequestBody): Uint8Array;
+    blocking(req: SyncSabRequestBody): SyncFsResult;
+}
+export declare function syncOps(kernel: JsSyncKernel, shared: SyncShared): Omit<JsSyncContext, 'run' | 'spawn' | 'exit' | 'kill' | 'cred' | 'setcred' | 'kernel' | 'umask'>;

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

@@ -0,0 +1,30 @@
+import type { JsKernel } from './js-kernel.js';
+export interface JsTermios {
+    c_iflag: number;
+    c_oflag: number;
+    c_cflag: number;
+    c_lflag: number;
+    c_cc: number[];
+}
+export interface JsTtySize {
+    columns: number;
+    rows: number;
+}
+export interface JsTty {
+    getAttr(fd: number): Promise<JsTermios>;
+    setAttr(fd: number, termios: JsTermios): Promise<void>;
+    setRaw(fd: number, raw: boolean): Promise<void>;
+    size(fd: number): Promise<JsTtySize>;
+    foreground(fd: number): Promise<number>;
+    setForeground(fd: number, pgrp: number): Promise<void>;
+}
+export declare function rawOf(termios: JsTermios): JsTermios;
+export declare function ttyOps(kernel: JsKernel): {
+    tty: JsTty;
+    restore(): Promise<void>;
+    modes(): Array<{
+        terminal: string;
+        fd: number;
+        termios: JsTermios;
+    }>;
+};

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

@@ -0,0 +1,21 @@
+import { type JsKernel } from './js-kernel.js';
+export type JsWebSocketMessage = string | Uint8Array;
+export interface JsWebSocketClose {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+}
+export interface JsWebSocketOptions {
+    protocols?: string | string[];
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+}
+export interface JsWebSocket {
+    readonly url: string;
+    readonly protocol: string;
+    readonly readable: ReadableStream<JsWebSocketMessage>;
+    readonly writable: WritableStream<JsWebSocketMessage>;
+    readonly closed: Promise<JsWebSocketClose>;
+    close(close?: Partial<JsWebSocketClose>): void;
+}
+export declare function websocketOp(kernel: JsKernel): (input: string | URL, options?: JsWebSocketOptions) => Promise<JsWebSocket>;